home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / TreeC1.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  108KB  |  3,311 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_General
  16. #include "General.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Texts
  28. #include "Texts.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sets
  32. #include "Sets.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeC2
  36. #include "TreeC2.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Strings
  44. #include "Strings.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_TreeC1
  48. #include "TreeC1.h"
  49. #endif
  50.  
  51. IO_tFile TreeC1_yyf;
  52. PROC TreeC1_Exit;
  53.  
  54. static INTEGER ConstCount, ListCount;
  55. static Idents_tIdent iRange, iClassName;
  56. static Tree_tTree Node;
  57. static SHORTCARD gBitCount;
  58. static SHORTCARD i, MaxBit;
  59. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  60. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  61. struct S_3 {
  62.     union {
  63.         char dummy;
  64.     } U_1;
  65. };
  66. static void ConstDecls ARGS((Tree_tTree t));
  67. struct S_4 {
  68.     union {
  69.         char dummy;
  70.     } U_1;
  71. };
  72. static void TypeDeclNode ARGS((Tree_tTree t));
  73. struct S_5 {
  74.     union {
  75.         char dummy;
  76.     } U_1;
  77. };
  78. static void TypeDeclRecord ARGS((Tree_tTree t));
  79. struct S_6 {
  80.     union {
  81.         char dummy;
  82.     } U_1;
  83. };
  84. static void ProcedureDeclsn ARGS((Tree_tTree t));
  85. struct S_7 {
  86.     union {
  87.         char dummy;
  88.     } U_1;
  89. };
  90. static void ProcedureDeclsm ARGS((Tree_tTree t));
  91. struct S_8 {
  92.     union {
  93.         char dummy;
  94.     } U_1;
  95. };
  96. static void ProcedureHeadingm ARGS((Tree_tTree t));
  97. struct S_9 {
  98.     union {
  99.         char dummy;
  100.     } U_1;
  101. };
  102. static void ProcedureHeadingm2 ARGS((Tree_tTree t));
  103. struct S_10 {
  104.     union {
  105.         char dummy;
  106.     } U_1;
  107. };
  108. struct S_11 {
  109.     union {
  110.         char dummy;
  111.     } U_1;
  112. };
  113. static void ProcedureBodyn ARGS((Tree_tTree t));
  114. struct S_12 {
  115.     union {
  116.         char dummy;
  117.     } U_1;
  118. };
  119. static void ProcedureBodym ARGS((Tree_tTree t));
  120. struct S_13 {
  121.     union {
  122.         char dummy;
  123.     } U_1;
  124. };
  125. static void ReleaseAttributes1 ARGS((Tree_tTree t));
  126. struct S_14 {
  127.     union {
  128.         char dummy;
  129.     } U_1;
  130. };
  131. static void ReleaseAttributes2 ARGS((Tree_tTree t));
  132. struct S_15 {
  133.     union {
  134.         char dummy;
  135.     } U_1;
  136. };
  137. static void TraverseTD ARGS((Tree_tTree t));
  138. struct S_16 {
  139.     union {
  140.         char dummy;
  141.     } U_1;
  142. };
  143. static void TraverseBU ARGS((Tree_tTree t));
  144. struct S_17 {
  145.     union {
  146.         char dummy;
  147.     } U_1;
  148. };
  149. static void Reverse1 ARGS((Tree_tTree t));
  150. struct S_18 {
  151.     union {
  152.         char dummy;
  153.     } U_1;
  154. };
  155. static void Reverse2 ARGS((Tree_tTree t));
  156. struct S_19 {
  157.     union {
  158.         char dummy;
  159.     } U_1;
  160. };
  161. static void Copy ARGS((Tree_tTree t));
  162. struct S_20 {
  163.     union {
  164.         char dummy;
  165.     } U_1;
  166. };
  167. static void CheckAttributes ARGS((Tree_tTree t));
  168. struct S_21 {
  169.     union {
  170.         char dummy;
  171.     } U_1;
  172. };
  173. static void InitTypeRange ARGS((Tree_tTree t));
  174. struct S_22 {
  175.     union {
  176.         char dummy;
  177.     } U_1;
  178. };
  179. static void InitTypeRange2 ARGS((Tree_tTree t));
  180. struct S_23 {
  181.     union {
  182.         char dummy;
  183.     } U_1;
  184. };
  185. static void QueryAttributes ARGS((Tree_tTree t));
  186. struct S_24 {
  187.     union {
  188.         char dummy;
  189.     } U_1;
  190. };
  191. static void IsEqualAttributes ARGS((Tree_tTree t));
  192. struct S_25 {
  193.     union {
  194.         char dummy;
  195.     } U_1;
  196. };
  197. static void InitAttributes ARGS((Tree_tTree t));
  198. struct S_26 {
  199.     union {
  200.         char dummy;
  201.     } U_1;
  202. };
  203. static void InitNodeSize ARGS((Tree_tTree t));
  204. struct S_27 {
  205.     union {
  206.         char dummy;
  207.     } U_1;
  208. };
  209. static void InitNodeName ARGS((Tree_tTree t));
  210. struct S_28 {
  211.     union {
  212.         char dummy;
  213.     } U_1;
  214. };
  215. static void CompMaxBit ARGS((Tree_tTree t));
  216. struct S_29 {
  217.     union {
  218.         char dummy;
  219.     } U_1;
  220. };
  221. static void yyExit ARGS(());
  222.  
  223.  
  224. static void yyAbort
  225. # ifdef __STDC__
  226. (CHAR yyFunction[], LONGCARD O_1)
  227. # else
  228. (yyFunction, O_1)
  229. CHAR yyFunction[];
  230. LONGCARD O_1;
  231. # endif
  232. {
  233.   OPEN_ARRAY_LOCALS
  234.  
  235.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  236.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  237.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module TreeC1, routine ", 30L);
  238.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  239.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  240.   IO_WriteNl((System_tFile)IO_StdError);
  241.   (*TreeC1_Exit)();
  242.   FREE_OPEN_ARRAYS
  243. }
  244.  
  245. static BOOLEAN yyIsEqual
  246. # ifdef __STDC__
  247. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  248. # else
  249. (yya, O_3, yyb, O_2)
  250. BYTE yya[];
  251. LONGCARD O_3;
  252. BYTE yyb[];
  253. LONGCARD O_2;
  254. # endif
  255. {
  256.   INTEGER yyi;
  257.   OPEN_ARRAY_LOCALS
  258.  
  259.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  260.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  261.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  262.   {
  263.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  264.  
  265.     if (B_1 <= B_2)
  266.       for (yyi = B_1;; yyi += 1) {
  267.         if (yya[yyi] != yyb[yyi]) {
  268.           FREE_OPEN_ARRAYS
  269.           return FALSE;
  270.         }
  271.         if (yyi >= B_2) break;
  272.       }
  273.   }
  274.   FREE_OPEN_ARRAYS
  275.   return TRUE;
  276. }
  277.  
  278. void TreeC1_TreeDefC
  279. # ifdef __STDC__
  280. (Tree_tTree t)
  281. # else
  282. (t)
  283. Tree_tTree t;
  284. # endif
  285. {
  286.   struct S_3 yyTempo;
  287.  
  288.   if (t == Tree_NoTree) {
  289.     return;
  290.   }
  291.   if (t->U_1.V_1.Kind == Tree_Ag) {
  292.     {
  293.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  294.  
  295.       IO_WriteS(Tree_f, (STRING)"# ifndef yy", 11L);
  296.       Tree_WI(Tree_iModule);
  297.       IO_WriteNl(Tree_f);
  298.       IO_WriteS(Tree_f, (STRING)"# define yy", 11L);
  299.       Tree_WI(Tree_iModule);
  300.       IO_WriteNl(Tree_f);
  301.       IO_WriteNl(Tree_f);
  302.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  303.       IO_WriteNl(Tree_f);
  304.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    parameters", 36L);
  305.       IO_WriteNl(Tree_f);
  306.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  307.       IO_WriteNl(Tree_f);
  308.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    ()", 28L);
  309.       IO_WriteNl(Tree_f);
  310.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  311.       IO_WriteNl(Tree_f);
  312.       IO_WriteNl(Tree_f);
  313.       if (Sets_IsElement(ORD('<'), &Tree_Options)) {
  314.         IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  315.         Tree_WI(Tree_iMain);
  316.         IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  317.         IO_WriteNl(Tree_f);
  318.       }
  319.       TreeC2_WriteLine(W_1->TreeCodes->U_1.V_12.Codes.ImportLine);
  320.       Texts_WriteText(Tree_f, W_1->TreeCodes->U_1.V_12.Codes.Import);
  321.       Node = W_1->Modules;
  322.       while (Node->U_1.V_1.Kind == Tree_Module) {
  323.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.ImportLine);
  324.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Import);
  325.         Node = Node->U_1.V_43.Module.Next;
  326.       }
  327.       IO_WriteNl(Tree_f);
  328.       IO_WriteS(Tree_f, (STRING)"# ifndef bool", 13L);
  329.       IO_WriteNl(Tree_f);
  330.       IO_WriteS(Tree_f, (STRING)"# define bool char", 18L);
  331.       IO_WriteNl(Tree_f);
  332.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  333.       IO_WriteNl(Tree_f);
  334.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  335.         IO_WriteS(Tree_f, (STRING)"# define ", 9L);
  336.         Tree_WI(Tree_iNoTree);
  337.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  338.         Tree_WI(Tree_itTree);
  339.         IO_WriteS(Tree_f, (STRING)") 0L", 4L);
  340.         IO_WriteNl(Tree_f);
  341.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ConstDecls);
  342.         IO_WriteNl(Tree_f);
  343.         if (Tree_ClassCount > 251) {
  344.           IO_WriteS(Tree_f, (STRING)"typedef unsigned short ", 23L);
  345.           Tree_WI(Tree_iMain);
  346.           IO_WriteS(Tree_f, (STRING)"_tKind;", 7L);
  347.           IO_WriteNl(Tree_f);
  348.         } else {
  349.           IO_WriteS(Tree_f, (STRING)"typedef unsigned char ", 22L);
  350.           Tree_WI(Tree_iMain);
  351.           IO_WriteS(Tree_f, (STRING)"_tKind;", 7L);
  352.           IO_WriteNl(Tree_f);
  353.         }
  354.         IO_WriteS(Tree_f, (STRING)"typedef unsigned short ", 23L);
  355.         Tree_WI(Tree_iMain);
  356.         IO_WriteS(Tree_f, (STRING)"_tMark;", 7L);
  357.         IO_WriteNl(Tree_f);
  358.         IO_WriteS(Tree_f, (STRING)"typedef unsigned short ", 23L);
  359.         Tree_WI(Tree_iMain);
  360.         IO_WriteS(Tree_f, (STRING)"_tLabel;", 8L);
  361.         IO_WriteNl(Tree_f);
  362.         IO_WriteS(Tree_f, (STRING)"typedef union ", 14L);
  363.         Tree_WI(Tree_iMain);
  364.         IO_WriteS(Tree_f, (STRING)"_Node * ", 8L);
  365.         Tree_WI(Tree_itTree);
  366.         IO_WriteS(Tree_f, (STRING)";", 1L);
  367.         IO_WriteNl(Tree_f);
  368.         IO_WriteS(Tree_f, (STRING)"typedef void (* ", 16L);
  369.         Tree_WI(Tree_iMain);
  370.         IO_WriteS(Tree_f, (STRING)"_tProcTree) ARGS((", 18L);
  371.         Tree_WI(Tree_itTree);
  372.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  373.         IO_WriteNl(Tree_f);
  374.       }
  375.       TreeC2_WriteLine(W_1->TreeCodes->U_1.V_12.Codes.ExportLine);
  376.       Texts_WriteText(Tree_f, W_1->TreeCodes->U_1.V_12.Codes.Export);
  377.       Node = W_1->Modules;
  378.       while (Node->U_1.V_1.Kind == Tree_Module) {
  379.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.ExportLine);
  380.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Export);
  381.         Node = Node->U_1.V_43.Module.Next;
  382.       }
  383.       IO_WriteNl(Tree_f);
  384.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  385.         IO_WriteS(Tree_f, (STRING)"# ifndef ", 9L);
  386.         Tree_WI(Tree_iMain);
  387.         IO_WriteS(Tree_f, (STRING)"_NodeHead", 9L);
  388.         IO_WriteNl(Tree_f);
  389.         IO_WriteS(Tree_f, (STRING)"# define ", 9L);
  390.         Tree_WI(Tree_iMain);
  391.         IO_WriteS(Tree_f, (STRING)"_NodeHead", 9L);
  392.         IO_WriteNl(Tree_f);
  393.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  394.         IO_WriteNl(Tree_f);
  395.         if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  396.           MaxBit = 0;
  397.           Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)CompMaxBit);
  398.           IO_WriteS(Tree_f, (STRING)"typedef struct { ", 17L);
  399.           Tree_WI(Tree_iMain);
  400.           IO_WriteS(Tree_f, (STRING)"_tKind yyKind; unsigned char yyIsComp0", 38L);
  401.           if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  402.             IO_WriteS(Tree_f, (STRING)", yyIsDone0", 11L);
  403.           }
  404.           {
  405.             SHORTCARD B_3 = 1, B_4 = (MaxBit - 1) / TreeC1_BSS;
  406.  
  407.             if (B_3 <= B_4)
  408.               for (i = B_3;; i += 1) {
  409.                 IO_WriteS(Tree_f, (STRING)", yyIsComp", 10L);
  410.                 Tree_WN((LONGINT)i);
  411.                 if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  412.                   IO_WriteS(Tree_f, (STRING)", yyIsDone", 10L);
  413.                   Tree_WN((LONGINT)i);
  414.                 }
  415.                 if (i >= B_4) break;
  416.               }
  417.           }
  418.           IO_WriteS(Tree_f, (STRING)"; ", 2L);
  419.           Tree_WI(Tree_iMain);
  420.           IO_WriteS(Tree_f, (STRING)"_tMark yyMark, yyOffset; ", 25L);
  421.           Tree_WI(Tree_itTree);
  422.           IO_WriteS(Tree_f, (STRING)" yyParent; ", 11L);
  423.           Tree_WI(Tree_iMain);
  424.           IO_WriteS(Tree_f, (STRING)"_NodeHead } ", 12L);
  425.           Tree_WI(Tree_iMain);
  426.           IO_WriteS(Tree_f, (STRING)"_tNodeHead;", 11L);
  427.           IO_WriteNl(Tree_f);
  428.         } else {
  429.           IO_WriteS(Tree_f, (STRING)"typedef struct { ", 17L);
  430.           Tree_WI(Tree_iMain);
  431.           IO_WriteS(Tree_f, (STRING)"_tKind yyKind; ", 15L);
  432.           Tree_WI(Tree_iMain);
  433.           IO_WriteS(Tree_f, (STRING)"_tMark yyMark; ", 15L);
  434.           Tree_WI(Tree_iMain);
  435.           IO_WriteS(Tree_f, (STRING)"_NodeHead } ", 12L);
  436.           Tree_WI(Tree_iMain);
  437.           IO_WriteS(Tree_f, (STRING)"_tNodeHead;", 11L);
  438.           IO_WriteNl(Tree_f);
  439.         }
  440.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)TypeDeclNode);
  441.         IO_WriteNl(Tree_f);
  442.         IO_WriteS(Tree_f, (STRING)"union ", 6L);
  443.         Tree_WI(Tree_iMain);
  444.         IO_WriteS(Tree_f, (STRING)"_Node {", 7L);
  445.         IO_WriteNl(Tree_f);
  446.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  447.         Tree_WI(Tree_iMain);
  448.         IO_WriteS(Tree_f, (STRING)"_tKind Kind;", 12L);
  449.         IO_WriteNl(Tree_f);
  450.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  451.         Tree_WI(Tree_iMain);
  452.         IO_WriteS(Tree_f, (STRING)"_tNodeHead yyHead;", 18L);
  453.         IO_WriteNl(Tree_f);
  454.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)TypeDeclRecord);
  455.         IO_WriteS(Tree_f, (STRING)"};", 2L);
  456.         IO_WriteNl(Tree_f);
  457.         IO_WriteNl(Tree_f);
  458.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  459.         Tree_WI(Tree_itTree);
  460.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  461.         Tree_WI(Tree_iMain);
  462.         IO_WriteS(Tree_f, (STRING)"Root;", 5L);
  463.         IO_WriteNl(Tree_f);
  464.         IO_WriteS(Tree_f, (STRING)"extern unsigned long ", 21L);
  465.         Tree_WI(Tree_iMain);
  466.         IO_WriteS(Tree_f, (STRING)"_HeapUsed;", 10L);
  467.         IO_WriteNl(Tree_f);
  468.         IO_WriteS(Tree_f, (STRING)"extern char * ", 14L);
  469.         Tree_WI(Tree_iMain);
  470.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr, * ", 16L);
  471.         Tree_WI(Tree_iMain);
  472.         IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr;", 12L);
  473.         IO_WriteNl(Tree_f);
  474.         IO_WriteS(Tree_f, (STRING)"extern unsigned short ", 22L);
  475.         Tree_WI(Tree_iMain);
  476.         IO_WriteS(Tree_f, (STRING)"_NodeSize [", 11L);
  477.         Tree_WN(Tree_ClassCount);
  478.         IO_WriteS(Tree_f, (STRING)" + 1];", 6L);
  479.         IO_WriteNl(Tree_f);
  480.         IO_WriteS(Tree_f, (STRING)"extern char * ", 14L);
  481.         Tree_WI(Tree_iMain);
  482.         IO_WriteS(Tree_f, (STRING)"_NodeName [", 11L);
  483.         Tree_WN(Tree_ClassCount);
  484.         IO_WriteS(Tree_f, (STRING)" + 1];", 6L);
  485.         IO_WriteNl(Tree_f);
  486.         IO_WriteNl(Tree_f);
  487.         IO_WriteS(Tree_f, (STRING)"extern void (* ", 15L);
  488.         Tree_WI(Tree_iMain);
  489.         IO_WriteS(Tree_f, (STRING)"_Exit) ();", 10L);
  490.         IO_WriteNl(Tree_f);
  491.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  492.         Tree_WI(Tree_itTree);
  493.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  494.         Tree_WI(Tree_iMain);
  495.         IO_WriteS(Tree_f, (STRING)"_Alloc ();", 10L);
  496.         IO_WriteNl(Tree_f);
  497.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  498.         Tree_WI(Tree_itTree);
  499.         IO_WriteS(Tree_f, (STRING)" Make", 5L);
  500.         Tree_WI(Tree_iMain);
  501.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  502.         Tree_WI(Tree_iMain);
  503.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind));", 16L);
  504.         IO_WriteNl(Tree_f);
  505.         IO_WriteS(Tree_f, (STRING)"extern bool ", 12L);
  506.         Tree_WI(Tree_iMain);
  507.         IO_WriteS(Tree_f, (STRING)"_IsType ARGS((register ", 23L);
  508.         Tree_WI(Tree_itTree);
  509.         IO_WriteS(Tree_f, (STRING)" yyt, register ", 15L);
  510.         Tree_WI(Tree_iMain);
  511.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind));", 16L);
  512.         IO_WriteNl(Tree_f);
  513.         IO_WriteNl(Tree_f);
  514.       }
  515.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  516.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ProcedureDeclsn);
  517.         IO_WriteNl(Tree_f);
  518.       }
  519.       if (Sets_IsElement(ORD('m'), &Tree_Options)) {
  520.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ProcedureDeclsm);
  521.         IO_WriteNl(Tree_f);
  522.       }
  523.       if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  524.         IO_WriteS(Tree_f, (STRING)"extern void Release", 19L);
  525.         Tree_WI(Tree_iModule);
  526.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  527.         Tree_WI(Tree_itTree);
  528.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  529.         IO_WriteNl(Tree_f);
  530.       }
  531.       if (Sets_IsElement(ORD('F'), &Tree_Options) && !Sets_IsElement(ORD('<'), &Tree_Options)) {
  532.         IO_WriteS(Tree_f, (STRING)"extern void Release", 19L);
  533.         Tree_WI(Tree_iModule);
  534.         IO_WriteS(Tree_f, (STRING)"Module ();", 10L);
  535.         IO_WriteNl(Tree_f);
  536.       }
  537.       if (Sets_IsElement(ORD('o'), &Tree_Options)) {
  538.         IO_WriteS(Tree_f, (STRING)"extern void Write", 17L);
  539.         Tree_WI(Tree_iModule);
  540.         IO_WriteS(Tree_f, (STRING)"Node ARGS((FILE * yyyf, ", 24L);
  541.         Tree_WI(Tree_itTree);
  542.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  543.         IO_WriteNl(Tree_f);
  544.       }
  545.       if (Sets_IsElement(ORD('w'), &Tree_Options)) {
  546.         IO_WriteS(Tree_f, (STRING)"extern void Write", 17L);
  547.         Tree_WI(Tree_iModule);
  548.         IO_WriteS(Tree_f, (STRING)" ARGS((FILE * yyyf, ", 20L);
  549.         Tree_WI(Tree_itTree);
  550.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  551.         IO_WriteNl(Tree_f);
  552.       }
  553.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  554.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  555.         Tree_WI(Tree_itTree);
  556.         IO_WriteS(Tree_f, (STRING)" Read", 5L);
  557.         Tree_WI(Tree_iModule);
  558.         IO_WriteS(Tree_f, (STRING)" ARGS((FILE * yyyf));", 21L);
  559.         IO_WriteNl(Tree_f);
  560.       }
  561.       if (Sets_IsElement(ORD('p'), &Tree_Options)) {
  562.         IO_WriteS(Tree_f, (STRING)"extern void Put", 15L);
  563.         Tree_WI(Tree_iModule);
  564.         IO_WriteS(Tree_f, (STRING)" ARGS((FILE * yyyf, ", 20L);
  565.         Tree_WI(Tree_itTree);
  566.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  567.         IO_WriteNl(Tree_f);
  568.       }
  569.       if (Sets_IsElement(ORD('g'), &Tree_Options)) {
  570.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  571.         Tree_WI(Tree_itTree);
  572.         IO_WriteS(Tree_f, (STRING)" Get", 4L);
  573.         Tree_WI(Tree_iModule);
  574.         IO_WriteS(Tree_f, (STRING)" ARGS((FILE * yyyf));", 21L);
  575.         IO_WriteNl(Tree_f);
  576.       }
  577.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  578.         IO_WriteS(Tree_f, (STRING)"extern void Traverse", 20L);
  579.         Tree_WI(Tree_iModule);
  580.         IO_WriteS(Tree_f, (STRING)"TD ARGS((", 9L);
  581.         Tree_WI(Tree_itTree);
  582.         IO_WriteS(Tree_f, (STRING)" yyt, ", 6L);
  583.         Tree_WI(Tree_iMain);
  584.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc));", 21L);
  585.         IO_WriteNl(Tree_f);
  586.       }
  587.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  588.         IO_WriteS(Tree_f, (STRING)"extern void Traverse", 20L);
  589.         Tree_WI(Tree_iModule);
  590.         IO_WriteS(Tree_f, (STRING)"BU ARGS((", 9L);
  591.         Tree_WI(Tree_itTree);
  592.         IO_WriteS(Tree_f, (STRING)" yyt, ", 6L);
  593.         Tree_WI(Tree_iMain);
  594.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc));", 21L);
  595.         IO_WriteNl(Tree_f);
  596.       }
  597.       if (Sets_IsElement(ORD('R'), &Tree_Options)) {
  598.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  599.         Tree_WI(Tree_itTree);
  600.         IO_WriteS(Tree_f, (STRING)" Reverse", 8L);
  601.         Tree_WI(Tree_iModule);
  602.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  603.         Tree_WI(Tree_itTree);
  604.         IO_WriteS(Tree_f, (STRING)" yyOld));", 9L);
  605.         IO_WriteNl(Tree_f);
  606.       }
  607.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  608.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  609.         Tree_WI(Tree_itTree);
  610.         IO_WriteS(Tree_f, (STRING)" Copy", 5L);
  611.         Tree_WI(Tree_iModule);
  612.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  613.         Tree_WI(Tree_itTree);
  614.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  615.         IO_WriteNl(Tree_f);
  616.       }
  617.       if (Sets_IsElement(ORD('k'), &Tree_Options)) {
  618.         IO_WriteS(Tree_f, (STRING)"extern bool Check", 17L);
  619.         Tree_WI(Tree_iModule);
  620.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  621.         Tree_WI(Tree_itTree);
  622.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  623.         IO_WriteNl(Tree_f);
  624.       }
  625.       if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  626.         IO_WriteS(Tree_f, (STRING)"extern void Query", 17L);
  627.         Tree_WI(Tree_iModule);
  628.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  629.         Tree_WI(Tree_itTree);
  630.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  631.         IO_WriteNl(Tree_f);
  632.       }
  633.       if (Sets_IsElement(ORD('='), &Tree_Options)) {
  634.         IO_WriteS(Tree_f, (STRING)"extern bool IsEqual", 19L);
  635.         Tree_WI(Tree_iModule);
  636.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  637.         Tree_WI(Tree_itTree);
  638.         IO_WriteS(Tree_f, (STRING)" yyt1, ", 7L);
  639.         Tree_WI(Tree_itTree);
  640.         IO_WriteS(Tree_f, (STRING)" yyt2));", 8L);
  641.         IO_WriteNl(Tree_f);
  642.       }
  643.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  644.         IO_WriteS(Tree_f, (STRING)"extern void Init", 16L);
  645.         Tree_WI(Tree_iModule);
  646.         IO_WriteS(Tree_f, (STRING)" ARGS((register ", 16L);
  647.         Tree_WI(Tree_itTree);
  648.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  649.         IO_WriteNl(Tree_f);
  650.       }
  651.       IO_WriteS(Tree_f, (STRING)"extern void Begin", 17L);
  652.       Tree_WI(Tree_iModule);
  653.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  654.       IO_WriteNl(Tree_f);
  655.       IO_WriteS(Tree_f, (STRING)"extern void Close", 17L);
  656.       Tree_WI(Tree_iModule);
  657.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  658.       IO_WriteNl(Tree_f);
  659.       IO_WriteNl(Tree_f);
  660.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  661.       IO_WriteNl(Tree_f);
  662.       return;
  663.     }
  664.   }
  665. }
  666.  
  667. static void ConstDecls
  668. # ifdef __STDC__
  669. (Tree_tTree t)
  670. # else
  671. (t)
  672. Tree_tTree t;
  673. # endif
  674. {
  675.   struct S_4 yyTempo;
  676.  
  677.   if (t == Tree_NoTree) {
  678.     return;
  679.   }
  680.   if (t->U_1.V_1.Kind == Tree_Class) {
  681.     {
  682.       register Tree_yClass *W_2 = &t->U_1.V_5.Class;
  683.  
  684.       if (!IN(Tree_Abstract, W_2->Properties)) {
  685.         INC(ConstCount);
  686.         if (!IN(Tree_Ignore, W_2->Properties)) {
  687.           IO_WriteS(Tree_f, (STRING)"# define k", 10L);
  688.           Tree_WI(W_2->Name);
  689.           IO_WriteS(Tree_f, (STRING)" ", 1L);
  690.           Tree_WN(ConstCount);
  691.           IO_WriteNl(Tree_f);
  692.         }
  693.       }
  694.       return;
  695.     }
  696.   }
  697. }
  698.  
  699. static void TypeDeclNode
  700. # ifdef __STDC__
  701. (Tree_tTree t)
  702. # else
  703. (t)
  704. Tree_tTree t;
  705. # endif
  706. {
  707.   struct S_5 yyTempo;
  708.  
  709.   if (t == Tree_NoTree) {
  710.     return;
  711.   }
  712.   if (t->U_1.V_1.Kind == Tree_Class) {
  713.     {
  714.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  715.  
  716.       if ((Tree_NoCodeClass & W_3->Properties) == 0X0L) {
  717.         IO_WriteS(Tree_f, (STRING)"typedef struct { ", 17L);
  718.         Tree_WI(Tree_iMain);
  719.         IO_WriteS(Tree_f, (STRING)"_tNodeHead yyHead; ", 19L);
  720.         Tree_ForallAttributes(t, (Tree_ProcOfT)TypeDeclNode);
  721.         IO_WriteS(Tree_f, (STRING)"} y", 3L);
  722.         Tree_WI(W_3->Name);
  723.         IO_WriteS(Tree_f, (STRING)";", 1L);
  724.         IO_WriteNl(Tree_f);
  725.       }
  726.       return;
  727.     }
  728.   }
  729.   if (t->U_1.V_1.Kind == Tree_Child) {
  730.     {
  731.       register Tree_yChild *W_4 = &t->U_1.V_9.Child;
  732.  
  733.       Tree_WI(Tree_itTree);
  734.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  735.       Tree_WI(W_4->Name);
  736.       IO_WriteS(Tree_f, (STRING)"; ", 2L);
  737.       return;
  738.     }
  739.   }
  740.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  741.     {
  742.       register Tree_yAttribute *W_5 = &t->U_1.V_10.Attribute;
  743.  
  744.       if ((Tree_NoCodeAttr & W_5->Properties) == 0X0L) {
  745.         Tree_WI(W_5->Type);
  746.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  747.         Tree_WI(W_5->Name);
  748.         IO_WriteS(Tree_f, (STRING)"; ", 2L);
  749.       }
  750.       return;
  751.     }
  752.   }
  753. }
  754.  
  755. static void TypeDeclRecord
  756. # ifdef __STDC__
  757. (Tree_tTree t)
  758. # else
  759. (t)
  760. Tree_tTree t;
  761. # endif
  762. {
  763.   struct S_6 yyTempo;
  764.  
  765.   if (t == Tree_NoTree) {
  766.     return;
  767.   }
  768.   if (t->U_1.V_1.Kind == Tree_Class) {
  769.     {
  770.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  771.  
  772.       if ((Tree_NoCodeClass & W_6->Properties) == 0X0L) {
  773.         IO_WriteS(Tree_f, (STRING)" y", 2L);
  774.         Tree_WI(W_6->Name);
  775.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  776.         Tree_WI(W_6->Name);
  777.         IO_WriteS(Tree_f, (STRING)";", 1L);
  778.         IO_WriteNl(Tree_f);
  779.       }
  780.       return;
  781.     }
  782.   }
  783. }
  784.  
  785. static void ProcedureDeclsn
  786. # ifdef __STDC__
  787. (Tree_tTree t)
  788. # else
  789. (t)
  790. Tree_tTree t;
  791. # endif
  792. {
  793.   struct S_7 yyTempo;
  794.  
  795.   if (t == Tree_NoTree) {
  796.     return;
  797.   }
  798.   if (t->U_1.V_1.Kind == Tree_Class) {
  799.     {
  800.       register Tree_yClass *W_7 = &t->U_1.V_5.Class;
  801.  
  802.       if ((Tree_NoCodeClass & W_7->Properties) == 0X0L) {
  803.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  804.         Tree_WI(Tree_itTree);
  805.         IO_WriteS(Tree_f, (STRING)" n", 2L);
  806.         Tree_WI(W_7->Name);
  807.         IO_WriteS(Tree_f, (STRING)" ();", 4L);
  808.         IO_WriteNl(Tree_f);
  809.       }
  810.       return;
  811.     }
  812.   }
  813. }
  814.  
  815. static void ProcedureDeclsm
  816. # ifdef __STDC__
  817. (Tree_tTree t)
  818. # else
  819. (t)
  820. Tree_tTree t;
  821. # endif
  822. {
  823.   struct S_8 yyTempo;
  824.  
  825.   if (t == Tree_NoTree) {
  826.     return;
  827.   }
  828.   if (t->U_1.V_1.Kind == Tree_Class) {
  829.     {
  830.       register Tree_yClass *W_8 = &t->U_1.V_5.Class;
  831.  
  832.       if ((Tree_NoCodeClass & W_8->Properties) == 0X0L) {
  833.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  834.         Tree_WI(Tree_itTree);
  835.         IO_WriteS(Tree_f, (STRING)" m", 2L);
  836.         Tree_WI(W_8->Name);
  837.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  838.         ListCount = 0;
  839.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureDeclsm);
  840.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  841.         IO_WriteNl(Tree_f);
  842.       }
  843.       return;
  844.     }
  845.   }
  846.   if (t->U_1.V_1.Kind == Tree_Child) {
  847.     {
  848.       register Tree_yChild *W_9 = &t->U_1.V_9.Child;
  849.  
  850.       if (IN(Tree_Input, W_9->Properties)) {
  851.         if (ListCount > 0) {
  852.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  853.         }
  854.         Tree_WI(Tree_itTree);
  855.         IO_WriteS(Tree_f, (STRING)" p", 2L);
  856.         Tree_WI(W_9->Name);
  857.         INC(ListCount);
  858.       }
  859.       return;
  860.     }
  861.   }
  862.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  863.     {
  864.       register Tree_yAttribute *W_10 = &t->U_1.V_10.Attribute;
  865.  
  866.       if (IN(Tree_Input, W_10->Properties)) {
  867.         if (ListCount > 0) {
  868.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  869.         }
  870.         Tree_WI(W_10->Type);
  871.         IO_WriteS(Tree_f, (STRING)" p", 2L);
  872.         Tree_WI(W_10->Name);
  873.         INC(ListCount);
  874.       }
  875.       return;
  876.     }
  877.   }
  878. }
  879.  
  880. static void ProcedureHeadingm
  881. # ifdef __STDC__
  882. (Tree_tTree t)
  883. # else
  884. (t)
  885. Tree_tTree t;
  886. # endif
  887. {
  888.   struct S_9 yyTempo;
  889.  
  890.   if (t == Tree_NoTree) {
  891.     return;
  892.   }
  893.   if (t->U_1.V_1.Kind == Tree_Class) {
  894.     {
  895.       register Tree_yClass *W_11 = &t->U_1.V_5.Class;
  896.  
  897.       if ((Tree_NoCodeClass & W_11->Properties) == 0X0L) {
  898.         Tree_WI(Tree_itTree);
  899.         IO_WriteS(Tree_f, (STRING)" m", 2L);
  900.         Tree_WI(W_11->Name);
  901.         IO_WriteNl(Tree_f);
  902.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  903.         IO_WriteNl(Tree_f);
  904.         ListCount = 0;
  905.         IO_WriteS(Tree_f, (STRING)"(", 1L);
  906.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureDeclsm);
  907.         IO_WriteS(Tree_f, (STRING)")", 1L);
  908.         IO_WriteNl(Tree_f);
  909.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  910.         IO_WriteNl(Tree_f);
  911.         ListCount = 0;
  912.         IO_WriteS(Tree_f, (STRING)"(", 1L);
  913.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureHeadingm);
  914.         IO_WriteS(Tree_f, (STRING)")", 1L);
  915.         IO_WriteNl(Tree_f);
  916.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureHeadingm2);
  917.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  918.         IO_WriteNl(Tree_f);
  919.       }
  920.       return;
  921.     }
  922.   }
  923.   if (t->U_1.V_1.Kind == Tree_Child) {
  924.     {
  925.       register Tree_yChild *W_12 = &t->U_1.V_9.Child;
  926.  
  927.       if (IN(Tree_Input, W_12->Properties)) {
  928.         if (ListCount > 0) {
  929.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  930.         }
  931.         IO_WriteS(Tree_f, (STRING)"p", 1L);
  932.         Tree_WI(W_12->Name);
  933.         INC(ListCount);
  934.       }
  935.       return;
  936.     }
  937.   }
  938.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  939.     {
  940.       register Tree_yAttribute *W_13 = &t->U_1.V_10.Attribute;
  941.  
  942.       if (IN(Tree_Input, W_13->Properties)) {
  943.         if (ListCount > 0) {
  944.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  945.         }
  946.         IO_WriteS(Tree_f, (STRING)"p", 1L);
  947.         Tree_WI(W_13->Name);
  948.         INC(ListCount);
  949.       }
  950.       return;
  951.     }
  952.   }
  953. }
  954.  
  955. static void ProcedureHeadingm2
  956. # ifdef __STDC__
  957. (Tree_tTree t)
  958. # else
  959. (t)
  960. Tree_tTree t;
  961. # endif
  962. {
  963.   struct S_10 yyTempo;
  964.  
  965.   if (t == Tree_NoTree) {
  966.     return;
  967.   }
  968.   if (t->U_1.V_1.Kind == Tree_Child) {
  969.     {
  970.       register Tree_yChild *W_14 = &t->U_1.V_9.Child;
  971.  
  972.       if (IN(Tree_Input, W_14->Properties)) {
  973.         Tree_WI(Tree_itTree);
  974.         IO_WriteS(Tree_f, (STRING)" p", 2L);
  975.         Tree_WI(W_14->Name);
  976.         IO_WriteS(Tree_f, (STRING)";", 1L);
  977.         IO_WriteNl(Tree_f);
  978.       }
  979.       return;
  980.     }
  981.   }
  982.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  983.     {
  984.       register Tree_yAttribute *W_15 = &t->U_1.V_10.Attribute;
  985.  
  986.       if (IN(Tree_Input, W_15->Properties)) {
  987.         Tree_WI(W_15->Type);
  988.         IO_WriteS(Tree_f, (STRING)" p", 2L);
  989.         Tree_WI(W_15->Name);
  990.         IO_WriteS(Tree_f, (STRING)";", 1L);
  991.         IO_WriteNl(Tree_f);
  992.       }
  993.       return;
  994.     }
  995.   }
  996. }
  997.  
  998. void TreeC1_TreeImplC
  999. # ifdef __STDC__
  1000. (Tree_tTree t)
  1001. # else
  1002. (t)
  1003. Tree_tTree t;
  1004. # endif
  1005. {
  1006.   struct S_11 yyTempo;
  1007.  
  1008.   if (t == Tree_NoTree) {
  1009.     return;
  1010.   }
  1011.   if (t->U_1.V_1.Kind == Tree_Ag) {
  1012.     {
  1013.       register Tree_yAg *W_16 = &t->U_1.V_26.Ag;
  1014.  
  1015.       IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  1016.       Tree_WI(Tree_iMain);
  1017.       IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  1018.       IO_WriteNl(Tree_f);
  1019.       IO_WriteS(Tree_f, (STRING)"# define yyALLOC(ptr, size)    if ((ptr = (", 40L);
  1020.       Tree_WI(Tree_itTree);
  1021.       IO_WriteS(Tree_f, (STRING)") ", 2L);
  1022.       Tree_WI(Tree_iMain);
  1023.       IO_WriteS(Tree_f, (STRING)"_PoolFreePtr) >= (", 18L);
  1024.       Tree_WI(Tree_itTree);
  1025.       IO_WriteS(Tree_f, (STRING)") ", 2L);
  1026.       Tree_WI(Tree_iMain);
  1027.       IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr) \\", 14L);
  1028.       IO_WriteNl(Tree_f);
  1029.       IO_WriteS(Tree_f, (STRING)"  ptr = ", 8L);
  1030.       Tree_WI(Tree_iMain);
  1031.       IO_WriteS(Tree_f, (STRING)"_Alloc (); \\", 12L);
  1032.       IO_WriteNl(Tree_f);
  1033.       IO_WriteS(Tree_f, (STRING)"  ", 2L);
  1034.       Tree_WI(Tree_iMain);
  1035.       IO_WriteS(Tree_f, (STRING)"_PoolFreePtr += size;", 21L);
  1036.       IO_WriteNl(Tree_f);
  1037.       IO_WriteS(Tree_f, (STRING)"# define yyFREE(ptr, size)    ", 27L);
  1038.       IO_WriteNl(Tree_f);
  1039.       IO_WriteS(Tree_f, (STRING)"# include <stdio.h>", 19L);
  1040.       IO_WriteNl(Tree_f);
  1041.       IO_WriteS(Tree_f, (STRING)"# ifdef __cplusplus", 19L);
  1042.       IO_WriteNl(Tree_f);
  1043.       IO_WriteS(Tree_f, (STRING)"extern \"C\" {", 12L);
  1044.       IO_WriteNl(Tree_f);
  1045.       IO_WriteS(Tree_f, (STRING)"# include \"System.h\"", 20L);
  1046.       IO_WriteNl(Tree_f);
  1047.       IO_WriteS(Tree_f, (STRING)"# include \"General.h\"", 21L);
  1048.       IO_WriteNl(Tree_f);
  1049.       IO_WriteS(Tree_f, (STRING)"# include \"Memory.h\"", 20L);
  1050.       IO_WriteNl(Tree_f);
  1051.       IO_WriteS(Tree_f, (STRING)"# include \"DynArray.h\"", 22L);
  1052.       IO_WriteNl(Tree_f);
  1053.       IO_WriteS(Tree_f, (STRING)"# include \"StringMem.h\"", 23L);
  1054.       IO_WriteNl(Tree_f);
  1055.       IO_WriteS(Tree_f, (STRING)"# include \"Idents.h\"", 20L);
  1056.       IO_WriteNl(Tree_f);
  1057.       IO_WriteS(Tree_f, (STRING)"# include \"Sets.h\"", 18L);
  1058.       IO_WriteNl(Tree_f);
  1059.       IO_WriteS(Tree_f, (STRING)"# include \"Positions.h\"", 23L);
  1060.       IO_WriteNl(Tree_f);
  1061.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1062.       IO_WriteNl(Tree_f);
  1063.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1064.       IO_WriteNl(Tree_f);
  1065.       IO_WriteS(Tree_f, (STRING)"# include \"System.h\"", 20L);
  1066.       IO_WriteNl(Tree_f);
  1067.       IO_WriteS(Tree_f, (STRING)"# include \"General.h\"", 21L);
  1068.       IO_WriteNl(Tree_f);
  1069.       IO_WriteS(Tree_f, (STRING)"# include \"Memory.h\"", 20L);
  1070.       IO_WriteNl(Tree_f);
  1071.       IO_WriteS(Tree_f, (STRING)"# include \"DynArray.h\"", 22L);
  1072.       IO_WriteNl(Tree_f);
  1073.       IO_WriteS(Tree_f, (STRING)"# include \"StringMem.h\"", 23L);
  1074.       IO_WriteNl(Tree_f);
  1075.       IO_WriteS(Tree_f, (STRING)"# include \"Idents.h\"", 20L);
  1076.       IO_WriteNl(Tree_f);
  1077.       IO_WriteS(Tree_f, (STRING)"# include \"Sets.h\"", 18L);
  1078.       IO_WriteNl(Tree_f);
  1079.       IO_WriteS(Tree_f, (STRING)"# include \"Positions.h\"", 23L);
  1080.       IO_WriteNl(Tree_f);
  1081.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1082.       IO_WriteNl(Tree_f);
  1083.       IO_WriteNl(Tree_f);
  1084.       TreeC2_WriteLine(W_16->TreeCodes->U_1.V_12.Codes.GlobalLine);
  1085.       Texts_WriteText(Tree_f, W_16->TreeCodes->U_1.V_12.Codes.Global);
  1086.       Node = W_16->Modules;
  1087.       while (Node->U_1.V_1.Kind == Tree_Module) {
  1088.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.GlobalLine);
  1089.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Global);
  1090.         Node = Node->U_1.V_43.Module.Next;
  1091.       }
  1092.       TreeC2_WriteLine(W_16->TreeCodes->U_1.V_12.Codes.LocalLine);
  1093.       Texts_WriteText(Tree_f, W_16->TreeCodes->U_1.V_12.Codes.Local);
  1094.       Node = W_16->Modules;
  1095.       while (Node->U_1.V_1.Kind == Tree_Module) {
  1096.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.LocalLine);
  1097.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Local);
  1098.         Node = Node->U_1.V_43.Module.Next;
  1099.       }
  1100.       IO_WriteS(Tree_f, (STRING)"# ifdef getchar", 15L);
  1101.       IO_WriteNl(Tree_f);
  1102.       IO_WriteS(Tree_f, (STRING)"# undef getchar", 15L);
  1103.       IO_WriteNl(Tree_f);
  1104.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1105.       IO_WriteNl(Tree_f);
  1106.       IO_WriteS(Tree_f, (STRING)"# ifdef putchar", 15L);
  1107.       IO_WriteNl(Tree_f);
  1108.       IO_WriteS(Tree_f, (STRING)"# undef putchar", 15L);
  1109.       IO_WriteNl(Tree_f);
  1110.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1111.       IO_WriteNl(Tree_f);
  1112.       IO_WriteS(Tree_f, (STRING)"# include \"yy", 13L);
  1113.       Tree_WI(Tree_iModule);
  1114.       IO_WriteS(Tree_f, (STRING)".w\"", 3L);
  1115.       IO_WriteNl(Tree_f);
  1116.       IO_WriteNl(Tree_f);
  1117.       if (!Sets_IsElement(ORD('<'), &Tree_Options)) {
  1118.         IO_WriteS(Tree_f, (STRING)"static void yyExit () { Exit (1); }", 35L);
  1119.         IO_WriteNl(Tree_f);
  1120.         IO_WriteNl(Tree_f);
  1121.         IO_WriteS(Tree_f, (STRING)"void (* ", 8L);
  1122.         Tree_WI(Tree_iMain);
  1123.         IO_WriteS(Tree_f, (STRING)"_Exit) () = yyExit;", 19L);
  1124.         IO_WriteNl(Tree_f);
  1125.         IO_WriteNl(Tree_f);
  1126.         IO_WriteS(Tree_f, (STRING)"# define yyBlockSize 20480", 26L);
  1127.         IO_WriteNl(Tree_f);
  1128.         IO_WriteNl(Tree_f);
  1129.         IO_WriteS(Tree_f, (STRING)"typedef struct yysBlock {", 25L);
  1130.         IO_WriteNl(Tree_f);
  1131.         IO_WriteS(Tree_f, (STRING)" char yyBlock [yyBlockSize];", 28L);
  1132.         IO_WriteNl(Tree_f);
  1133.         IO_WriteS(Tree_f, (STRING)" struct yysBlock * yySuccessor;", 31L);
  1134.         IO_WriteNl(Tree_f);
  1135.         IO_WriteS(Tree_f, (STRING)"} yytBlock, * yytBlockPtr;", 26L);
  1136.         IO_WriteNl(Tree_f);
  1137.         IO_WriteNl(Tree_f);
  1138.         Tree_WI(Tree_itTree);
  1139.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1140.         Tree_WI(Tree_iMain);
  1141.         IO_WriteS(Tree_f, (STRING)"Root;", 5L);
  1142.         IO_WriteNl(Tree_f);
  1143.         IO_WriteS(Tree_f, (STRING)"unsigned long ", 14L);
  1144.         Tree_WI(Tree_iMain);
  1145.         IO_WriteS(Tree_f, (STRING)"_HeapUsed = 0;", 14L);
  1146.         IO_WriteNl(Tree_f);
  1147.         IO_WriteNl(Tree_f);
  1148.         IO_WriteS(Tree_f, (STRING)"static yytBlockPtr yyBlockList    = (yytBlockPtr) ", 47L);
  1149.         Tree_WI(Tree_iNoTree);
  1150.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1151.         IO_WriteNl(Tree_f);
  1152.         IO_WriteS(Tree_f, (STRING)"char * ", 7L);
  1153.         Tree_WI(Tree_iMain);
  1154.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr    = (char *) ", 24L);
  1155.         Tree_WI(Tree_iNoTree);
  1156.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1157.         IO_WriteNl(Tree_f);
  1158.         IO_WriteS(Tree_f, (STRING)"char * ", 7L);
  1159.         Tree_WI(Tree_iMain);
  1160.         IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr    = (char *) ", 23L);
  1161.         Tree_WI(Tree_iNoTree);
  1162.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1163.         IO_WriteNl(Tree_f);
  1164.         IO_WriteS(Tree_f, (STRING)"static unsigned short yyMaxSize    = 0;", 36L);
  1165.         IO_WriteNl(Tree_f);
  1166.         IO_WriteS(Tree_f, (STRING)"unsigned short ", 15L);
  1167.         Tree_WI(Tree_iMain);
  1168.         IO_WriteS(Tree_f, (STRING)"_NodeSize [", 11L);
  1169.         Tree_WN(Tree_ClassCount);
  1170.         IO_WriteS(Tree_f, (STRING)" + 1] = { 0,", 12L);
  1171.         IO_WriteNl(Tree_f);
  1172.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)InitNodeSize);
  1173.         IO_WriteS(Tree_f, (STRING)"};", 2L);
  1174.         IO_WriteNl(Tree_f);
  1175.         IO_WriteS(Tree_f, (STRING)"char * ", 7L);
  1176.         Tree_WI(Tree_iMain);
  1177.         IO_WriteS(Tree_f, (STRING)"_NodeName [", 11L);
  1178.         Tree_WN(Tree_ClassCount);
  1179.         IO_WriteS(Tree_f, (STRING)" + 1] = {", 9L);
  1180.         IO_WriteNl(Tree_f);
  1181.         IO_WriteS(Tree_f, (STRING)" \"", 2L);
  1182.         Tree_WI(Tree_iNoTree);
  1183.         IO_WriteS(Tree_f, (STRING)"\",", 2L);
  1184.         IO_WriteNl(Tree_f);
  1185.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)InitNodeName);
  1186.         IO_WriteS(Tree_f, (STRING)"};", 2L);
  1187.         IO_WriteNl(Tree_f);
  1188.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1189.         Tree_WI(Tree_iMain);
  1190.         IO_WriteS(Tree_f, (STRING)"_tKind yyTypeRange [", 20L);
  1191.         Tree_WN(Tree_ClassCount);
  1192.         IO_WriteS(Tree_f, (STRING)" + 1] = { 0,", 12L);
  1193.         IO_WriteNl(Tree_f);
  1194.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)InitTypeRange);
  1195.         IO_WriteS(Tree_f, (STRING)"};", 2L);
  1196.         IO_WriteNl(Tree_f);
  1197.         IO_WriteNl(Tree_f);
  1198.         Tree_WI(Tree_itTree);
  1199.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1200.         Tree_WI(Tree_iMain);
  1201.         IO_WriteS(Tree_f, (STRING)"_Alloc ()", 9L);
  1202.         IO_WriteNl(Tree_f);
  1203.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1204.         IO_WriteNl(Tree_f);
  1205.         IO_WriteS(Tree_f, (STRING)" register yytBlockPtr yyBlockPtr = yyBlockList;", 47L);
  1206.         IO_WriteNl(Tree_f);
  1207.         IO_WriteS(Tree_f, (STRING)" register int i;", 16L);
  1208.         IO_WriteNl(Tree_f);
  1209.         IO_WriteNl(Tree_f);
  1210.         IO_WriteS(Tree_f, (STRING)" if (yyMaxSize == 0)", 20L);
  1211.         IO_WriteNl(Tree_f);
  1212.         IO_WriteS(Tree_f, (STRING)"  for (i = 1; i <= ", 19L);
  1213.         Tree_WN(Tree_ClassCount);
  1214.         IO_WriteS(Tree_f, (STRING)"; i ++) {", 9L);
  1215.         IO_WriteNl(Tree_f);
  1216.         IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1217.         Tree_WI(Tree_iMain);
  1218.         IO_WriteS(Tree_f, (STRING)"_NodeSize [i] = (", 17L);
  1219.         Tree_WI(Tree_iMain);
  1220.         IO_WriteS(Tree_f, (STRING)"_NodeSize [i] + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign];", 60L);
  1221.         IO_WriteNl(Tree_f);
  1222.         IO_WriteS(Tree_f, (STRING)"   yyMaxSize = Max (", 20L);
  1223.         Tree_WI(Tree_iMain);
  1224.         IO_WriteS(Tree_f, (STRING)"_NodeSize [i], yyMaxSize);", 26L);
  1225.         IO_WriteNl(Tree_f);
  1226.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1227.         IO_WriteNl(Tree_f);
  1228.         IO_WriteS(Tree_f, (STRING)" yyBlockList = (yytBlockPtr) Alloc (sizeof (yytBlock));", 55L);
  1229.         IO_WriteNl(Tree_f);
  1230.         IO_WriteS(Tree_f, (STRING)" yyBlockList->yySuccessor = yyBlockPtr;", 39L);
  1231.         IO_WriteNl(Tree_f);
  1232.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1233.         Tree_WI(Tree_iMain);
  1234.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr = yyBlockList->yyBlock;", 36L);
  1235.         IO_WriteNl(Tree_f);
  1236.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1237.         Tree_WI(Tree_iMain);
  1238.         IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr = ", 14L);
  1239.         Tree_WI(Tree_iMain);
  1240.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr + yyBlockSize - yyMaxSize + 1;", 43L);
  1241.         IO_WriteNl(Tree_f);
  1242.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1243.         Tree_WI(Tree_iMain);
  1244.         IO_WriteS(Tree_f, (STRING)"_HeapUsed += yyBlockSize;", 25L);
  1245.         IO_WriteNl(Tree_f);
  1246.         IO_WriteS(Tree_f, (STRING)" return (", 9L);
  1247.         Tree_WI(Tree_itTree);
  1248.         IO_WriteS(Tree_f, (STRING)") ", 2L);
  1249.         Tree_WI(Tree_iMain);
  1250.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr;", 13L);
  1251.         IO_WriteNl(Tree_f);
  1252.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1253.         IO_WriteNl(Tree_f);
  1254.         IO_WriteNl(Tree_f);
  1255.         Tree_WI(Tree_itTree);
  1256.         IO_WriteS(Tree_f, (STRING)" Make", 5L);
  1257.         Tree_WI(Tree_iMain);
  1258.         IO_WriteNl(Tree_f);
  1259.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1260.         IO_WriteNl(Tree_f);
  1261.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1262.         Tree_WI(Tree_iMain);
  1263.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind)", 14L);
  1264.         IO_WriteNl(Tree_f);
  1265.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1266.         IO_WriteNl(Tree_f);
  1267.         IO_WriteS(Tree_f, (STRING)" (yyKind) ", 10L);
  1268.         Tree_WI(Tree_iMain);
  1269.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind;", 14L);
  1270.         IO_WriteNl(Tree_f);
  1271.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1272.         IO_WriteNl(Tree_f);
  1273.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1274.         IO_WriteNl(Tree_f);
  1275.         IO_WriteS(Tree_f, (STRING)" register ", 10L);
  1276.         Tree_WI(Tree_itTree);
  1277.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1278.         IO_WriteNl(Tree_f);
  1279.         IO_WriteS(Tree_f, (STRING)" yyALLOC (yyt, ", 15L);
  1280.         Tree_WI(Tree_iMain);
  1281.         IO_WriteS(Tree_f, (STRING)"_NodeSize [yyKind])", 19L);
  1282.         IO_WriteNl(Tree_f);
  1283.         IO_WriteS(Tree_f, (STRING)" yyt->Kind = yyKind;", 20L);
  1284.         IO_WriteNl(Tree_f);
  1285.         IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyMark = 0;", 24L);
  1286.         IO_WriteNl(Tree_f);
  1287.         if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  1288.           IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyParent = ", 24L);
  1289.           Tree_WI(Tree_iNoTree);
  1290.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1291.           IO_WriteNl(Tree_f);
  1292.         }
  1293.         IO_WriteS(Tree_f, (STRING)" return yyt;", 12L);
  1294.         IO_WriteNl(Tree_f);
  1295.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1296.         IO_WriteNl(Tree_f);
  1297.         IO_WriteNl(Tree_f);
  1298.         IO_WriteS(Tree_f, (STRING)"bool ", 5L);
  1299.         Tree_WI(Tree_iMain);
  1300.         IO_WriteS(Tree_f, (STRING)"_IsType", 7L);
  1301.         IO_WriteNl(Tree_f);
  1302.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1303.         IO_WriteNl(Tree_f);
  1304.         IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  1305.         Tree_WI(Tree_itTree);
  1306.         IO_WriteS(Tree_f, (STRING)" yyt, register ", 15L);
  1307.         Tree_WI(Tree_iMain);
  1308.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind)", 14L);
  1309.         IO_WriteNl(Tree_f);
  1310.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1311.         IO_WriteNl(Tree_f);
  1312.         IO_WriteS(Tree_f, (STRING)" (yyt, yyKind) register ", 24L);
  1313.         Tree_WI(Tree_itTree);
  1314.         IO_WriteS(Tree_f, (STRING)" yyt; register ", 15L);
  1315.         Tree_WI(Tree_iMain);
  1316.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind;", 14L);
  1317.         IO_WriteNl(Tree_f);
  1318.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1319.         IO_WriteNl(Tree_f);
  1320.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1321.         IO_WriteNl(Tree_f);
  1322.         IO_WriteS(Tree_f, (STRING)" return yyt != ", 15L);
  1323.         Tree_WI(Tree_iNoTree);
  1324.         IO_WriteS(Tree_f, (STRING)" && yyKind <= yyt->Kind && yyt->Kind <= yyTypeRange [yyKind];", 61L);
  1325.         IO_WriteNl(Tree_f);
  1326.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1327.         IO_WriteNl(Tree_f);
  1328.         IO_WriteNl(Tree_f);
  1329.       }
  1330.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  1331.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)ProcedureBodyn);
  1332.       }
  1333.       IO_WriteNl(Tree_f);
  1334.       if (Sets_IsElement(ORD('m'), &Tree_Options)) {
  1335.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)ProcedureBodym);
  1336.       }
  1337.       TreeC2_TreeIO(t);
  1338.       if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  1339.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1340.         Tree_WI(Tree_itTree);
  1341.         IO_WriteS(Tree_f, (STRING)" yyChild;", 9L);
  1342.         IO_WriteNl(Tree_f);
  1343.         IO_WriteNl(Tree_f);
  1344.         IO_WriteS(Tree_f, (STRING)"static void yyRelease", 21L);
  1345.         Tree_WI(Tree_iModule);
  1346.         IO_WriteNl(Tree_f);
  1347.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1348.         IO_WriteNl(Tree_f);
  1349.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1350.         Tree_WI(Tree_itTree);
  1351.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1352.         IO_WriteNl(Tree_f);
  1353.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1354.         IO_WriteNl(Tree_f);
  1355.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1356.         Tree_WI(Tree_itTree);
  1357.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1358.         IO_WriteNl(Tree_f);
  1359.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1360.         IO_WriteNl(Tree_f);
  1361.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1362.         IO_WriteNl(Tree_f);
  1363.         IO_WriteS(Tree_f, (STRING)" if (yyt == ", 12L);
  1364.         Tree_WI(Tree_iNoTree);
  1365.         IO_WriteS(Tree_f, (STRING)") return;", 9L);
  1366.         IO_WriteNl(Tree_f);
  1367.         IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  1368.         IO_WriteNl(Tree_f);
  1369.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)ReleaseAttributes1);
  1370.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  1371.         IO_WriteNl(Tree_f);
  1372.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1373.         IO_WriteNl(Tree_f);
  1374.         IO_WriteNl(Tree_f);
  1375.         IO_WriteS(Tree_f, (STRING)" if (-- yyt->yyHead.yyMark == 0) {", 34L);
  1376.         IO_WriteNl(Tree_f);
  1377.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  1378.         IO_WriteNl(Tree_f);
  1379.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)ReleaseAttributes2);
  1380.         IO_WriteS(Tree_f, (STRING)"  default: ;", 12L);
  1381.         IO_WriteNl(Tree_f);
  1382.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1383.         IO_WriteNl(Tree_f);
  1384.         IO_WriteS(Tree_f, (STRING)"  yyFREE (yyt, ", 15L);
  1385.         Tree_WI(Tree_iMain);
  1386.         IO_WriteS(Tree_f, (STRING)"_NodeSize [yyt->Kind])", 22L);
  1387.         IO_WriteNl(Tree_f);
  1388.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1389.         IO_WriteNl(Tree_f);
  1390.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1391.         IO_WriteNl(Tree_f);
  1392.         IO_WriteNl(Tree_f);
  1393.         IO_WriteS(Tree_f, (STRING)"void Release", 12L);
  1394.         Tree_WI(Tree_iModule);
  1395.         IO_WriteNl(Tree_f);
  1396.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1397.         IO_WriteNl(Tree_f);
  1398.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1399.         Tree_WI(Tree_itTree);
  1400.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1401.         IO_WriteNl(Tree_f);
  1402.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1403.         IO_WriteNl(Tree_f);
  1404.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1405.         Tree_WI(Tree_itTree);
  1406.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1407.         IO_WriteNl(Tree_f);
  1408.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1409.         IO_WriteNl(Tree_f);
  1410.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1411.         IO_WriteNl(Tree_f);
  1412.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  1413.         IO_WriteNl(Tree_f);
  1414.         IO_WriteS(Tree_f, (STRING)" yyRelease", 10L);
  1415.         Tree_WI(Tree_iModule);
  1416.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  1417.         IO_WriteNl(Tree_f);
  1418.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1419.         IO_WriteNl(Tree_f);
  1420.         IO_WriteNl(Tree_f);
  1421.       }
  1422.       if (Sets_IsElement(ORD('F'), &Tree_Options) && !Sets_IsElement(ORD('<'), &Tree_Options)) {
  1423.         IO_WriteS(Tree_f, (STRING)"void Release", 12L);
  1424.         Tree_WI(Tree_iModule);
  1425.         IO_WriteS(Tree_f, (STRING)"Module ()", 9L);
  1426.         IO_WriteNl(Tree_f);
  1427.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1428.         IO_WriteNl(Tree_f);
  1429.         IO_WriteS(Tree_f, (STRING)" yytBlockPtr yyBlockPtr;", 24L);
  1430.         IO_WriteNl(Tree_f);
  1431.         IO_WriteS(Tree_f, (STRING)" while (yyBlockList != (yytBlockPtr) ", 37L);
  1432.         Tree_WI(Tree_iNoTree);
  1433.         IO_WriteS(Tree_f, (STRING)") {", 3L);
  1434.         IO_WriteNl(Tree_f);
  1435.         IO_WriteS(Tree_f, (STRING)"  yyBlockPtr = yyBlockList;", 27L);
  1436.         IO_WriteNl(Tree_f);
  1437.         IO_WriteS(Tree_f, (STRING)"  yyBlockList = yyBlockList->yySuccessor;", 41L);
  1438.         IO_WriteNl(Tree_f);
  1439.         IO_WriteS(Tree_f, (STRING)"  Free (sizeof (yytBlock), (char *) yyBlockPtr);", 48L);
  1440.         IO_WriteNl(Tree_f);
  1441.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1442.         IO_WriteNl(Tree_f);
  1443.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1444.         Tree_WI(Tree_iMain);
  1445.         IO_WriteS(Tree_f, (STRING)"_PoolFreePtr = (char *) ", 24L);
  1446.         Tree_WI(Tree_iNoTree);
  1447.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1448.         IO_WriteNl(Tree_f);
  1449.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1450.         Tree_WI(Tree_iMain);
  1451.         IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr = (char *) ", 23L);
  1452.         Tree_WI(Tree_iNoTree);
  1453.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1454.         IO_WriteNl(Tree_f);
  1455.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1456.         Tree_WI(Tree_iMain);
  1457.         IO_WriteS(Tree_f, (STRING)"_HeapUsed = 0;", 14L);
  1458.         IO_WriteNl(Tree_f);
  1459.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1460.         IO_WriteNl(Tree_f);
  1461.         IO_WriteNl(Tree_f);
  1462.       }
  1463.       if (Sets_IsElement(ORD('t'), &Tree_Options) || Sets_IsElement(ORD('b'), &Tree_Options)) {
  1464.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1465.         Tree_WI(Tree_iMain);
  1466.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyProc;", 18L);
  1467.         IO_WriteNl(Tree_f);
  1468.         IO_WriteNl(Tree_f);
  1469.       }
  1470.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  1471.         IO_WriteS(Tree_f, (STRING)"static void yyTraverse", 22L);
  1472.         Tree_WI(Tree_iModule);
  1473.         IO_WriteS(Tree_f, (STRING)"TD", 2L);
  1474.         IO_WriteNl(Tree_f);
  1475.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1476.         IO_WriteNl(Tree_f);
  1477.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1478.         Tree_WI(Tree_itTree);
  1479.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1480.         IO_WriteNl(Tree_f);
  1481.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1482.         IO_WriteNl(Tree_f);
  1483.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1484.         Tree_WI(Tree_itTree);
  1485.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1486.         IO_WriteNl(Tree_f);
  1487.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1488.         IO_WriteNl(Tree_f);
  1489.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1490.         IO_WriteNl(Tree_f);
  1491.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  1492.         IO_WriteNl(Tree_f);
  1493.         IO_WriteS(Tree_f, (STRING)"  if (yyt == ", 13L);
  1494.         Tree_WI(Tree_iNoTree);
  1495.         IO_WriteS(Tree_f, (STRING)" || yyt->yyHead.yyMark == 0) return;", 36L);
  1496.         IO_WriteNl(Tree_f);
  1497.         IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyMark = 0;", 25L);
  1498.         IO_WriteNl(Tree_f);
  1499.         IO_WriteS(Tree_f, (STRING)"  yyProc (yyt);", 15L);
  1500.         IO_WriteNl(Tree_f);
  1501.         IO_WriteNl(Tree_f);
  1502.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  1503.         IO_WriteNl(Tree_f);
  1504.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)TraverseTD);
  1505.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  1506.         IO_WriteNl(Tree_f);
  1507.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1508.         IO_WriteNl(Tree_f);
  1509.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1510.         IO_WriteNl(Tree_f);
  1511.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1512.         IO_WriteNl(Tree_f);
  1513.         IO_WriteNl(Tree_f);
  1514.         IO_WriteS(Tree_f, (STRING)"void Traverse", 13L);
  1515.         Tree_WI(Tree_iModule);
  1516.         IO_WriteS(Tree_f, (STRING)"TD", 2L);
  1517.         IO_WriteNl(Tree_f);
  1518.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1519.         IO_WriteNl(Tree_f);
  1520.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1521.         Tree_WI(Tree_itTree);
  1522.         IO_WriteS(Tree_f, (STRING)" yyt, ", 6L);
  1523.         Tree_WI(Tree_iMain);
  1524.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc)", 19L);
  1525.         IO_WriteNl(Tree_f);
  1526.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1527.         IO_WriteNl(Tree_f);
  1528.         IO_WriteS(Tree_f, (STRING)" (yyt, yyyProc) ", 16L);
  1529.         Tree_WI(Tree_itTree);
  1530.         IO_WriteS(Tree_f, (STRING)" yyt; ", 6L);
  1531.         Tree_WI(Tree_iMain);
  1532.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc;", 19L);
  1533.         IO_WriteNl(Tree_f);
  1534.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1535.         IO_WriteNl(Tree_f);
  1536.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1537.         IO_WriteNl(Tree_f);
  1538.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  1539.         IO_WriteNl(Tree_f);
  1540.         IO_WriteS(Tree_f, (STRING)" yyProc = yyyProc;", 18L);
  1541.         IO_WriteNl(Tree_f);
  1542.         IO_WriteS(Tree_f, (STRING)" yyTraverse", 11L);
  1543.         Tree_WI(Tree_iModule);
  1544.         IO_WriteS(Tree_f, (STRING)"TD (yyt);", 9L);
  1545.         IO_WriteNl(Tree_f);
  1546.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1547.         IO_WriteNl(Tree_f);
  1548.         IO_WriteNl(Tree_f);
  1549.       }
  1550.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  1551.         IO_WriteS(Tree_f, (STRING)"static void yyTraverse", 22L);
  1552.         Tree_WI(Tree_iModule);
  1553.         IO_WriteS(Tree_f, (STRING)"BU", 2L);
  1554.         IO_WriteNl(Tree_f);
  1555.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1556.         IO_WriteNl(Tree_f);
  1557.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1558.         Tree_WI(Tree_itTree);
  1559.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1560.         IO_WriteNl(Tree_f);
  1561.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1562.         IO_WriteNl(Tree_f);
  1563.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1564.         Tree_WI(Tree_itTree);
  1565.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1566.         IO_WriteNl(Tree_f);
  1567.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1568.         IO_WriteNl(Tree_f);
  1569.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1570.         IO_WriteNl(Tree_f);
  1571.         IO_WriteS(Tree_f, (STRING)" if (yyt == ", 12L);
  1572.         Tree_WI(Tree_iNoTree);
  1573.         IO_WriteS(Tree_f, (STRING)" || yyt->yyHead.yyMark == 0) return;", 36L);
  1574.         IO_WriteNl(Tree_f);
  1575.         IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyMark = 0;", 24L);
  1576.         IO_WriteNl(Tree_f);
  1577.         IO_WriteNl(Tree_f);
  1578.         IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  1579.         IO_WriteNl(Tree_f);
  1580.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)TraverseBU);
  1581.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  1582.         IO_WriteNl(Tree_f);
  1583.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1584.         IO_WriteNl(Tree_f);
  1585.         IO_WriteS(Tree_f, (STRING)" yyProc (yyt);", 14L);
  1586.         IO_WriteNl(Tree_f);
  1587.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1588.         IO_WriteNl(Tree_f);
  1589.         IO_WriteNl(Tree_f);
  1590.         IO_WriteS(Tree_f, (STRING)"void Traverse", 13L);
  1591.         Tree_WI(Tree_iModule);
  1592.         IO_WriteS(Tree_f, (STRING)"BU", 2L);
  1593.         IO_WriteNl(Tree_f);
  1594.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1595.         IO_WriteNl(Tree_f);
  1596.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1597.         Tree_WI(Tree_itTree);
  1598.         IO_WriteS(Tree_f, (STRING)" yyt, ", 6L);
  1599.         Tree_WI(Tree_iMain);
  1600.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc)", 19L);
  1601.         IO_WriteNl(Tree_f);
  1602.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1603.         IO_WriteNl(Tree_f);
  1604.         IO_WriteS(Tree_f, (STRING)" (yyt, yyyProc) ", 16L);
  1605.         Tree_WI(Tree_itTree);
  1606.         IO_WriteS(Tree_f, (STRING)" yyt; ", 6L);
  1607.         Tree_WI(Tree_iMain);
  1608.         IO_WriteS(Tree_f, (STRING)"_tProcTree yyyProc;", 19L);
  1609.         IO_WriteNl(Tree_f);
  1610.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1611.         IO_WriteNl(Tree_f);
  1612.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1613.         IO_WriteNl(Tree_f);
  1614.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  1615.         IO_WriteNl(Tree_f);
  1616.         IO_WriteS(Tree_f, (STRING)" yyProc = yyyProc;", 18L);
  1617.         IO_WriteNl(Tree_f);
  1618.         IO_WriteS(Tree_f, (STRING)" yyTraverse", 11L);
  1619.         Tree_WI(Tree_iModule);
  1620.         IO_WriteS(Tree_f, (STRING)"BU (yyt);", 9L);
  1621.         IO_WriteNl(Tree_f);
  1622.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1623.         IO_WriteNl(Tree_f);
  1624.         IO_WriteNl(Tree_f);
  1625.       }
  1626.       if (Sets_IsElement(ORD('R'), &Tree_Options)) {
  1627.         Tree_WI(Tree_itTree);
  1628.         IO_WriteS(Tree_f, (STRING)" Reverse", 8L);
  1629.         Tree_WI(Tree_iModule);
  1630.         IO_WriteNl(Tree_f);
  1631.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1632.         IO_WriteNl(Tree_f);
  1633.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1634.         Tree_WI(Tree_itTree);
  1635.         IO_WriteS(Tree_f, (STRING)" yyOld)", 7L);
  1636.         IO_WriteNl(Tree_f);
  1637.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1638.         IO_WriteNl(Tree_f);
  1639.         IO_WriteS(Tree_f, (STRING)" (yyOld) ", 9L);
  1640.         Tree_WI(Tree_itTree);
  1641.         IO_WriteS(Tree_f, (STRING)" yyOld;", 7L);
  1642.         IO_WriteNl(Tree_f);
  1643.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1644.         IO_WriteNl(Tree_f);
  1645.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1646.         IO_WriteNl(Tree_f);
  1647.         IO_WriteS(Tree_f, (STRING)" register ", 10L);
  1648.         Tree_WI(Tree_itTree);
  1649.         IO_WriteS(Tree_f, (STRING)" yyNew, yyNext, yyTail;", 23L);
  1650.         IO_WriteNl(Tree_f);
  1651.         IO_WriteS(Tree_f, (STRING)" yyNew = yyOld;", 15L);
  1652.         IO_WriteNl(Tree_f);
  1653.         IO_WriteS(Tree_f, (STRING)" yyTail = yyOld;", 16L);
  1654.         IO_WriteNl(Tree_f);
  1655.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  1656.         IO_WriteNl(Tree_f);
  1657.         IO_WriteS(Tree_f, (STRING)"  switch (yyOld->Kind) {", 24L);
  1658.         IO_WriteNl(Tree_f);
  1659.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)Reverse1);
  1660.         IO_WriteS(Tree_f, (STRING)"  default: goto yyExit;", 23L);
  1661.         IO_WriteNl(Tree_f);
  1662.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1663.         IO_WriteNl(Tree_f);
  1664.         IO_WriteS(Tree_f, (STRING)"  yyNew = yyOld;", 16L);
  1665.         IO_WriteNl(Tree_f);
  1666.         IO_WriteS(Tree_f, (STRING)"  yyOld = yyNext;", 17L);
  1667.         IO_WriteNl(Tree_f);
  1668.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1669.         IO_WriteNl(Tree_f);
  1670.         IO_WriteS(Tree_f, (STRING)"yyExit:", 7L);
  1671.         IO_WriteNl(Tree_f);
  1672.         IO_WriteS(Tree_f, (STRING)" switch (yyTail->Kind) {", 24L);
  1673.         IO_WriteNl(Tree_f);
  1674.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)Reverse2);
  1675.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  1676.         IO_WriteNl(Tree_f);
  1677.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1678.         IO_WriteNl(Tree_f);
  1679.         IO_WriteS(Tree_f, (STRING)" return yyNew;", 14L);
  1680.         IO_WriteNl(Tree_f);
  1681.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1682.         IO_WriteNl(Tree_f);
  1683.         IO_WriteNl(Tree_f);
  1684.       }
  1685.       if (Sets_IsElement(ORD('y'), &Tree_Options)) {
  1686.         IO_WriteS(Tree_f, (STRING)"# define yyInitOldToNewStoreSize 32", 35L);
  1687.         IO_WriteNl(Tree_f);
  1688.         IO_WriteNl(Tree_f);
  1689.         IO_WriteS(Tree_f, (STRING)"typedef struct { ", 17L);
  1690.         Tree_WI(Tree_itTree);
  1691.         IO_WriteS(Tree_f, (STRING)" yyOld, yyNew; } yytOldToNew;", 29L);
  1692.         IO_WriteNl(Tree_f);
  1693.         IO_WriteS(Tree_f, (STRING)"static unsigned long yyOldToNewStoreSize = yyInitOldToNewStoreSize;", 67L);
  1694.         IO_WriteNl(Tree_f);
  1695.         IO_WriteS(Tree_f, (STRING)"static yytOldToNew yyOldToNewStore [yyInitOldToNewStoreSize];", 61L);
  1696.         IO_WriteNl(Tree_f);
  1697.         IO_WriteS(Tree_f, (STRING)"static yytOldToNew * yyOldToNewStorePtr = yyOldToNewStore;", 58L);
  1698.         IO_WriteNl(Tree_f);
  1699.         IO_WriteS(Tree_f, (STRING)"static int yyOldToNewCount;", 27L);
  1700.         IO_WriteNl(Tree_f);
  1701.         IO_WriteNl(Tree_f);
  1702.         IO_WriteS(Tree_f, (STRING)"static void yyStoreOldToNew", 27L);
  1703.         IO_WriteNl(Tree_f);
  1704.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1705.         IO_WriteNl(Tree_f);
  1706.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1707.         Tree_WI(Tree_itTree);
  1708.         IO_WriteS(Tree_f, (STRING)" yyOld, ", 8L);
  1709.         Tree_WI(Tree_itTree);
  1710.         IO_WriteS(Tree_f, (STRING)" yyNew)", 7L);
  1711.         IO_WriteNl(Tree_f);
  1712.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1713.         IO_WriteNl(Tree_f);
  1714.         IO_WriteS(Tree_f, (STRING)" (yyOld, yyNew) ", 16L);
  1715.         Tree_WI(Tree_itTree);
  1716.         IO_WriteS(Tree_f, (STRING)" yyOld, yyNew;", 14L);
  1717.         IO_WriteNl(Tree_f);
  1718.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1719.         IO_WriteNl(Tree_f);
  1720.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1721.         IO_WriteNl(Tree_f);
  1722.         IO_WriteS(Tree_f, (STRING)" if (++ yyOldToNewCount == yyOldToNewStoreSize)", 47L);
  1723.         IO_WriteNl(Tree_f);
  1724.         IO_WriteS(Tree_f, (STRING)"  ExtendArray ((char * *) & yyOldToNewStorePtr, & yyOldToNewStoreSize, sizeof (yytOldToNew));", 93L);
  1725.         IO_WriteNl(Tree_f);
  1726.         IO_WriteS(Tree_f, (STRING)" yyOldToNewStorePtr [yyOldToNewCount].yyOld = yyOld;", 52L);
  1727.         IO_WriteNl(Tree_f);
  1728.         IO_WriteS(Tree_f, (STRING)" yyOldToNewStorePtr [yyOldToNewCount].yyNew = yyNew;", 52L);
  1729.         IO_WriteNl(Tree_f);
  1730.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1731.         IO_WriteNl(Tree_f);
  1732.         IO_WriteNl(Tree_f);
  1733.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1734.         Tree_WI(Tree_itTree);
  1735.         IO_WriteS(Tree_f, (STRING)" yyMapOldToNew", 14L);
  1736.         IO_WriteNl(Tree_f);
  1737.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1738.         IO_WriteNl(Tree_f);
  1739.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1740.         Tree_WI(Tree_itTree);
  1741.         IO_WriteS(Tree_f, (STRING)" yyOld)", 7L);
  1742.         IO_WriteNl(Tree_f);
  1743.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1744.         IO_WriteNl(Tree_f);
  1745.         IO_WriteS(Tree_f, (STRING)" (yyOld) ", 9L);
  1746.         Tree_WI(Tree_itTree);
  1747.         IO_WriteS(Tree_f, (STRING)" yyOld;", 7L);
  1748.         IO_WriteNl(Tree_f);
  1749.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1750.         IO_WriteNl(Tree_f);
  1751.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1752.         IO_WriteNl(Tree_f);
  1753.         IO_WriteS(Tree_f, (STRING)" register int yyi;", 18L);
  1754.         IO_WriteNl(Tree_f);
  1755.         IO_WriteS(Tree_f, (STRING)" for (yyi = 1; yyi <= yyOldToNewCount; yyi ++)", 46L);
  1756.         IO_WriteNl(Tree_f);
  1757.         IO_WriteS(Tree_f, (STRING)"  if (yyOldToNewStorePtr [yyi].yyOld == yyOld) return yyOldToNewStorePtr [yyi].yyNew;", 85L);
  1758.         IO_WriteNl(Tree_f);
  1759.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1760.         IO_WriteNl(Tree_f);
  1761.         IO_WriteNl(Tree_f);
  1762.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1763.         Tree_WI(Tree_itTree);
  1764.         IO_WriteS(Tree_f, (STRING)" yyCopy", 7L);
  1765.         Tree_WI(Tree_iModule);
  1766.         IO_WriteNl(Tree_f);
  1767.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1768.         IO_WriteNl(Tree_f);
  1769.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1770.         Tree_WI(Tree_itTree);
  1771.         IO_WriteS(Tree_f, (STRING)" yyt, yyPtrtTree yyNew)", 23L);
  1772.         IO_WriteNl(Tree_f);
  1773.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1774.         IO_WriteNl(Tree_f);
  1775.         IO_WriteS(Tree_f, (STRING)" (yyt, yyNew) ", 14L);
  1776.         Tree_WI(Tree_itTree);
  1777.         IO_WriteS(Tree_f, (STRING)" yyt; yyPtrtTree yyNew;", 23L);
  1778.         IO_WriteNl(Tree_f);
  1779.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1780.         IO_WriteNl(Tree_f);
  1781.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1782.         IO_WriteNl(Tree_f);
  1783.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  1784.         IO_WriteNl(Tree_f);
  1785.         IO_WriteS(Tree_f, (STRING)"  if (yyt == ", 13L);
  1786.         Tree_WI(Tree_iNoTree);
  1787.         IO_WriteS(Tree_f, (STRING)") { * yyNew = ", 14L);
  1788.         Tree_WI(Tree_iNoTree);
  1789.         IO_WriteS(Tree_f, (STRING)"; return; }", 11L);
  1790.         IO_WriteNl(Tree_f);
  1791.         IO_WriteS(Tree_f, (STRING)"  if (yyt->yyHead.yyMark == 0) { * yyNew = yyMapOldToNew (yyt); return; }", 73L);
  1792.         IO_WriteNl(Tree_f);
  1793.         IO_WriteS(Tree_f, (STRING)"  yyALLOC (* yyNew, ", 20L);
  1794.         Tree_WI(Tree_iMain);
  1795.         IO_WriteS(Tree_f, (STRING)"_NodeSize [yyt->Kind])", 22L);
  1796.         IO_WriteNl(Tree_f);
  1797.         IO_WriteS(Tree_f, (STRING)"  if (yyt->yyHead.yyMark > 1) { yyStoreOldToNew (yyt, * yyNew); }", 65L);
  1798.         IO_WriteNl(Tree_f);
  1799.         IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyMark = 0;", 25L);
  1800.         IO_WriteNl(Tree_f);
  1801.         IO_WriteNl(Tree_f);
  1802.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  1803.         IO_WriteNl(Tree_f);
  1804.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)Copy);
  1805.         IO_WriteS(Tree_f, (STRING)"  default: ;", 12L);
  1806.         IO_WriteNl(Tree_f);
  1807.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1808.         IO_WriteNl(Tree_f);
  1809.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1810.         IO_WriteNl(Tree_f);
  1811.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1812.         IO_WriteNl(Tree_f);
  1813.         IO_WriteNl(Tree_f);
  1814.         Tree_WI(Tree_itTree);
  1815.         IO_WriteS(Tree_f, (STRING)" Copy", 5L);
  1816.         Tree_WI(Tree_iModule);
  1817.         IO_WriteNl(Tree_f);
  1818.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1819.         IO_WriteNl(Tree_f);
  1820.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1821.         Tree_WI(Tree_itTree);
  1822.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1823.         IO_WriteNl(Tree_f);
  1824.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1825.         IO_WriteNl(Tree_f);
  1826.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1827.         Tree_WI(Tree_itTree);
  1828.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1829.         IO_WriteNl(Tree_f);
  1830.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1831.         IO_WriteNl(Tree_f);
  1832.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1833.         IO_WriteNl(Tree_f);
  1834.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1835.         Tree_WI(Tree_itTree);
  1836.         IO_WriteS(Tree_f, (STRING)" yyNew;", 7L);
  1837.         IO_WriteNl(Tree_f);
  1838.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  1839.         IO_WriteNl(Tree_f);
  1840.         IO_WriteS(Tree_f, (STRING)" yyOldToNewCount = 0;", 21L);
  1841.         IO_WriteNl(Tree_f);
  1842.         IO_WriteS(Tree_f, (STRING)" yyCopy", 7L);
  1843.         Tree_WI(Tree_iModule);
  1844.         IO_WriteS(Tree_f, (STRING)" (yyt, & yyNew);", 16L);
  1845.         IO_WriteNl(Tree_f);
  1846.         IO_WriteS(Tree_f, (STRING)" return yyNew;", 14L);
  1847.         IO_WriteNl(Tree_f);
  1848.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1849.         IO_WriteNl(Tree_f);
  1850.         IO_WriteNl(Tree_f);
  1851.       }
  1852.       if (Sets_IsElement(ORD('k'), &Tree_Options)) {
  1853.         IO_WriteS(Tree_f, (STRING)"static bool yyCheck", 19L);
  1854.         Tree_WI(Tree_iModule);
  1855.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  1856.         Tree_WI(Tree_itTree);
  1857.         IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  1858.         IO_WriteNl(Tree_f);
  1859.         IO_WriteNl(Tree_f);
  1860.         IO_WriteS(Tree_f, (STRING)"bool Check", 10L);
  1861.         Tree_WI(Tree_iModule);
  1862.         IO_WriteNl(Tree_f);
  1863.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1864.         IO_WriteNl(Tree_f);
  1865.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1866.         Tree_WI(Tree_itTree);
  1867.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1868.         IO_WriteNl(Tree_f);
  1869.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1870.         IO_WriteNl(Tree_f);
  1871.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1872.         Tree_WI(Tree_itTree);
  1873.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1874.         IO_WriteNl(Tree_f);
  1875.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1876.         IO_WriteNl(Tree_f);
  1877.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1878.         IO_WriteNl(Tree_f);
  1879.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  1880.         IO_WriteNl(Tree_f);
  1881.         IO_WriteS(Tree_f, (STRING)" return yyCheck", 15L);
  1882.         Tree_WI(Tree_iModule);
  1883.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  1884.         IO_WriteNl(Tree_f);
  1885.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1886.         IO_WriteNl(Tree_f);
  1887.         IO_WriteNl(Tree_f);
  1888.         IO_WriteS(Tree_f, (STRING)"static bool yyCheckChild", 24L);
  1889.         IO_WriteNl(Tree_f);
  1890.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1891.         IO_WriteNl(Tree_f);
  1892.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1893.         Tree_WI(Tree_itTree);
  1894.         IO_WriteS(Tree_f, (STRING)" yyParent, ", 11L);
  1895.         Tree_WI(Tree_itTree);
  1896.         IO_WriteS(Tree_f, (STRING)" yyyChild, ", 11L);
  1897.         Tree_WI(Tree_iMain);
  1898.         IO_WriteS(Tree_f, (STRING)"_tKind yyType, char * yySelector)", 33L);
  1899.         IO_WriteNl(Tree_f);
  1900.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1901.         IO_WriteNl(Tree_f);
  1902.         IO_WriteS(Tree_f, (STRING)" (yyParent, yyyChild, yyType, yySelector)", 41L);
  1903.         IO_WriteNl(Tree_f);
  1904.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1905.         Tree_WI(Tree_itTree);
  1906.         IO_WriteS(Tree_f, (STRING)" yyParent, yyyChild;", 20L);
  1907.         IO_WriteNl(Tree_f);
  1908.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1909.         Tree_WI(Tree_iMain);
  1910.         IO_WriteS(Tree_f, (STRING)"_tKind yyType;", 14L);
  1911.         IO_WriteNl(Tree_f);
  1912.         IO_WriteS(Tree_f, (STRING)" char * yySelector;", 19L);
  1913.         IO_WriteNl(Tree_f);
  1914.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1915.         IO_WriteNl(Tree_f);
  1916.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1917.         IO_WriteNl(Tree_f);
  1918.         IO_WriteS(Tree_f, (STRING)" bool yySuccess = ", 18L);
  1919.         Tree_WI(Tree_iMain);
  1920.         IO_WriteS(Tree_f, (STRING)"_IsType (yyyChild, yyType);", 27L);
  1921.         IO_WriteNl(Tree_f);
  1922.         IO_WriteS(Tree_f, (STRING)" if (! yySuccess) {", 19L);
  1923.         IO_WriteNl(Tree_f);
  1924.         IO_WriteS(Tree_f, (STRING)"  (void) fputs (\"CheckTree: parent = \", stderr);", 48L);
  1925.         IO_WriteNl(Tree_f);
  1926.         IO_WriteS(Tree_f, (STRING)"  Write", 7L);
  1927.         Tree_WI(Tree_iModule);
  1928.         IO_WriteS(Tree_f, (STRING)"Node (stderr, yyParent);", 24L);
  1929.         IO_WriteNl(Tree_f);
  1930.         IO_WriteS(Tree_f, (STRING)"  (void) fprintf (stderr, \"\\nselector: %s child = \", yySelector);", 65L);
  1931.         IO_WriteNl(Tree_f);
  1932.         IO_WriteS(Tree_f, (STRING)"  Write", 7L);
  1933.         Tree_WI(Tree_iModule);
  1934.         IO_WriteS(Tree_f, (STRING)"Node (stderr, yyyChild);", 24L);
  1935.         IO_WriteNl(Tree_f);
  1936.         IO_WriteS(Tree_f, (STRING)"  (void) fputc ('\\n', stderr);", 30L);
  1937.         IO_WriteNl(Tree_f);
  1938.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1939.         IO_WriteNl(Tree_f);
  1940.         IO_WriteS(Tree_f, (STRING)" return yyCheck", 15L);
  1941.         Tree_WI(Tree_iModule);
  1942.         IO_WriteS(Tree_f, (STRING)" (yyyChild) && yySuccess;", 25L);
  1943.         IO_WriteNl(Tree_f);
  1944.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1945.         IO_WriteNl(Tree_f);
  1946.         IO_WriteNl(Tree_f);
  1947.         IO_WriteS(Tree_f, (STRING)"static bool yyCheck", 19L);
  1948.         Tree_WI(Tree_iModule);
  1949.         IO_WriteNl(Tree_f);
  1950.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1951.         IO_WriteNl(Tree_f);
  1952.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1953.         Tree_WI(Tree_itTree);
  1954.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1955.         IO_WriteNl(Tree_f);
  1956.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1957.         IO_WriteNl(Tree_f);
  1958.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1959.         Tree_WI(Tree_itTree);
  1960.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1961.         IO_WriteNl(Tree_f);
  1962.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1963.         IO_WriteNl(Tree_f);
  1964.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1965.         IO_WriteNl(Tree_f);
  1966.         IO_WriteS(Tree_f, (STRING)" bool yyResult;", 15L);
  1967.         IO_WriteNl(Tree_f);
  1968.         IO_WriteS(Tree_f, (STRING)" if (yyt == ", 12L);
  1969.         Tree_WI(Tree_iNoTree);
  1970.         IO_WriteS(Tree_f, (STRING)") return false;", 15L);
  1971.         IO_WriteNl(Tree_f);
  1972.         IO_WriteS(Tree_f, (STRING)" else if (yyt->yyHead.yyMark == 0) return true;", 47L);
  1973.         IO_WriteNl(Tree_f);
  1974.         IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyMark = 0;", 24L);
  1975.         IO_WriteNl(Tree_f);
  1976.         IO_WriteNl(Tree_f);
  1977.         IO_WriteS(Tree_f, (STRING)" yyResult = true;", 17L);
  1978.         IO_WriteNl(Tree_f);
  1979.         IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  1980.         IO_WriteNl(Tree_f);
  1981.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)CheckAttributes);
  1982.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  1983.         IO_WriteNl(Tree_f);
  1984.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1985.         IO_WriteNl(Tree_f);
  1986.         IO_WriteS(Tree_f, (STRING)" return yyResult;", 17L);
  1987.         IO_WriteNl(Tree_f);
  1988.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1989.         IO_WriteNl(Tree_f);
  1990.         IO_WriteNl(Tree_f);
  1991.       }
  1992.       if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  1993.         IO_WriteS(Tree_f, (STRING)"# define yyyWrite    1", 19L);
  1994.         IO_WriteNl(Tree_f);
  1995.         IO_WriteS(Tree_f, (STRING)"# define yyyRead    2", 18L);
  1996.         IO_WriteNl(Tree_f);
  1997.         IO_WriteS(Tree_f, (STRING)"# define yyyQuit    3", 18L);
  1998.         IO_WriteNl(Tree_f);
  1999.         IO_WriteNl(Tree_f);
  2000.         IO_WriteS(Tree_f, (STRING)"static char yyyString [32], yyCh;", 33L);
  2001.         IO_WriteNl(Tree_f);
  2002.         IO_WriteS(Tree_f, (STRING)"static int yyLength, yyState;", 29L);
  2003.         IO_WriteNl(Tree_f);
  2004.         IO_WriteNl(Tree_f);
  2005.         IO_WriteS(Tree_f, (STRING)"static bool yyyIsEqual", 22L);
  2006.         IO_WriteNl(Tree_f);
  2007.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  2008.         IO_WriteNl(Tree_f);
  2009.         IO_WriteS(Tree_f, (STRING)" (char * yya)", 13L);
  2010.         IO_WriteNl(Tree_f);
  2011.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  2012.         IO_WriteNl(Tree_f);
  2013.         IO_WriteS(Tree_f, (STRING)" (yya) char * yya;", 18L);
  2014.         IO_WriteNl(Tree_f);
  2015.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  2016.         IO_WriteNl(Tree_f);
  2017.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  2018.         IO_WriteNl(Tree_f);
  2019.         IO_WriteS(Tree_f, (STRING)" register int yyi;", 18L);
  2020.         IO_WriteNl(Tree_f);
  2021.         IO_WriteS(Tree_f, (STRING)" if (yyLength >= 0 && yyyString [yyLength] == ' ') {", 52L);
  2022.         IO_WriteNl(Tree_f);
  2023.         IO_WriteS(Tree_f, (STRING)"  if (yyLength != strlen (yya)) return false;", 45L);
  2024.         IO_WriteNl(Tree_f);
  2025.         IO_WriteS(Tree_f, (STRING)"  for (yyi = 0; yyi < yyLength; yyi ++)", 39L);
  2026.         IO_WriteNl(Tree_f);
  2027.         IO_WriteS(Tree_f, (STRING)"   if (yyyString [yyi] != yya [yyi]) return false;", 50L);
  2028.         IO_WriteNl(Tree_f);
  2029.         IO_WriteS(Tree_f, (STRING)" } else {", 9L);
  2030.         IO_WriteNl(Tree_f);
  2031.         IO_WriteS(Tree_f, (STRING)"  if (yyLength >= strlen (yya)) return false;", 45L);
  2032.         IO_WriteNl(Tree_f);
  2033.         IO_WriteS(Tree_f, (STRING)"  for (yyi = 0; yyi <= yyLength; yyi ++)", 40L);
  2034.         IO_WriteNl(Tree_f);
  2035.         IO_WriteS(Tree_f, (STRING)"   if (yyyString [yyi] != yya [yyi]) return false;", 50L);
  2036.         IO_WriteNl(Tree_f);
  2037.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  2038.         IO_WriteNl(Tree_f);
  2039.         IO_WriteS(Tree_f, (STRING)" return true;", 13L);
  2040.         IO_WriteNl(Tree_f);
  2041.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2042.         IO_WriteNl(Tree_f);
  2043.         IO_WriteNl(Tree_f);
  2044.         IO_WriteS(Tree_f, (STRING)"void Query", 10L);
  2045.         Tree_WI(Tree_iModule);
  2046.         IO_WriteNl(Tree_f);
  2047.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  2048.         IO_WriteNl(Tree_f);
  2049.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  2050.         Tree_WI(Tree_itTree);
  2051.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  2052.         IO_WriteNl(Tree_f);
  2053.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  2054.         IO_WriteNl(Tree_f);
  2055.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  2056.         Tree_WI(Tree_itTree);
  2057.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  2058.         IO_WriteNl(Tree_f);
  2059.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  2060.         IO_WriteNl(Tree_f);
  2061.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  2062.         IO_WriteNl(Tree_f);
  2063.         IO_WriteS(Tree_f, (STRING)" yyState = yyyWrite;", 20L);
  2064.         IO_WriteNl(Tree_f);
  2065.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  2066.         IO_WriteNl(Tree_f);
  2067.         IO_WriteS(Tree_f, (STRING)"  switch (yyState) {", 20L);
  2068.         IO_WriteNl(Tree_f);
  2069.         IO_WriteS(Tree_f, (STRING)"  case yyyQuit : return;", 24L);
  2070.         IO_WriteNl(Tree_f);
  2071.         IO_WriteS(Tree_f, (STRING)"  case yyyWrite: Write", 22L);
  2072.         Tree_WI(Tree_iModule);
  2073.         IO_WriteS(Tree_f, (STRING)"Node (stdout, yyt); yyState = yyyRead;", 38L);
  2074.         IO_WriteNl(Tree_f);
  2075.         IO_WriteS(Tree_f, (STRING)"  case yyyRead : (void) printf (\"? \"); yyLength = -1; yyCh = getc (stdin);", 74L);
  2076.         IO_WriteNl(Tree_f);
  2077.         IO_WriteS(Tree_f, (STRING)"   while (yyCh != ", 18L);
  2078.         IO_WriteS(Tree_f, (STRING)"'\\n' && yyCh > 0)", 17L);
  2079.         IO_WriteNl(Tree_f);
  2080.         IO_WriteS(Tree_f, (STRING)"    { yyyString [++ yyLength] = yyCh; yyCh = getc (stdin); }", 60L);
  2081.         IO_WriteNl(Tree_f);
  2082.         IO_WriteS(Tree_f, (STRING)"   if (yyCh < 0) { (void) fputs (\"QueryTree: eof reached\\n\", stderr);", 69L);
  2083.         IO_WriteNl(Tree_f);
  2084.         IO_WriteS(Tree_f, (STRING)"    yyState = yyyQuit; return; }", 32L);
  2085.         IO_WriteNl(Tree_f);
  2086.         IO_WriteS(Tree_f, (STRING)"   if      (yyyIsEqual (\"parent\")) { yyState = yyyWrite; return; }", 66L);
  2087.         IO_WriteNl(Tree_f);
  2088.         IO_WriteS(Tree_f, (STRING)"   else if (yyyIsEqual (\"quit\"  )) { yyState = yyyQuit ; return; }", 66L);
  2089.         IO_WriteNl(Tree_f);
  2090.         IO_WriteS(Tree_f, (STRING)"   else if (yyt != ", 19L);
  2091.         Tree_WI(Tree_iNoTree);
  2092.         IO_WriteS(Tree_f, (STRING)") {", 3L);
  2093.         IO_WriteNl(Tree_f);
  2094.         IO_WriteS(Tree_f, (STRING)"    switch (yyt->Kind) {", 24L);
  2095.         IO_WriteNl(Tree_f);
  2096.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)QueryAttributes);
  2097.         IO_WriteS(Tree_f, (STRING)"    default: ;", 14L);
  2098.         IO_WriteNl(Tree_f);
  2099.         IO_WriteS(Tree_f, (STRING)"    }", 5L);
  2100.         IO_WriteNl(Tree_f);
  2101.         IO_WriteS(Tree_f, (STRING)"   }", 4L);
  2102.         IO_WriteNl(Tree_f);
  2103.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2104.         IO_WriteNl(Tree_f);
  2105.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  2106.         IO_WriteNl(Tree_f);
  2107.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2108.         IO_WriteNl(Tree_f);
  2109.         IO_WriteNl(Tree_f);
  2110.       }
  2111.       if (Sets_IsElement(ORD('='), &Tree_Options)) {
  2112.         IO_WriteS(Tree_f, (STRING)"bool IsEqual", 12L);
  2113.         Tree_WI(Tree_iModule);
  2114.         IO_WriteNl(Tree_f);
  2115.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  2116.         IO_WriteNl(Tree_f);
  2117.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  2118.         Tree_WI(Tree_itTree);
  2119.         IO_WriteS(Tree_f, (STRING)" yyt1, ", 7L);
  2120.         Tree_WI(Tree_itTree);
  2121.         IO_WriteS(Tree_f, (STRING)" yyt2)", 6L);
  2122.         IO_WriteNl(Tree_f);
  2123.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  2124.         IO_WriteNl(Tree_f);
  2125.         IO_WriteS(Tree_f, (STRING)" (yyt1, yyt2) ", 14L);
  2126.         Tree_WI(Tree_itTree);
  2127.         IO_WriteS(Tree_f, (STRING)" yyt1, yyt2;", 12L);
  2128.         IO_WriteNl(Tree_f);
  2129.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  2130.         IO_WriteNl(Tree_f);
  2131.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  2132.         IO_WriteNl(Tree_f);
  2133.         IO_WriteS(Tree_f, (STRING)" if (yyt1 == yyt2) return true;", 31L);
  2134.         IO_WriteNl(Tree_f);
  2135.         IO_WriteS(Tree_f, (STRING)" if (yyt1 == ", 13L);
  2136.         Tree_WI(Tree_iNoTree);
  2137.         IO_WriteS(Tree_f, (STRING)" || yyt2 == ", 12L);
  2138.         Tree_WI(Tree_iNoTree);
  2139.         IO_WriteS(Tree_f, (STRING)" || yyt1->Kind != yyt2->Kind) return false;", 43L);
  2140.         IO_WriteNl(Tree_f);
  2141.         IO_WriteS(Tree_f, (STRING)" switch (yyt1->Kind) {", 22L);
  2142.         IO_WriteNl(Tree_f);
  2143.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)IsEqualAttributes);
  2144.         IO_WriteS(Tree_f, (STRING)" default: return true;", 22L);
  2145.         IO_WriteNl(Tree_f);
  2146.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  2147.         IO_WriteNl(Tree_f);
  2148.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2149.         IO_WriteNl(Tree_f);
  2150.         IO_WriteNl(Tree_f);
  2151.       }
  2152.       if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  2153.         MaxBit = 0;
  2154.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)CompMaxBit);
  2155.         IO_WriteS(Tree_f, (STRING)"void Init", 9L);
  2156.         Tree_WI(Tree_iModule);
  2157.         IO_WriteNl(Tree_f);
  2158.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  2159.         IO_WriteNl(Tree_f);
  2160.         IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  2161.         Tree_WI(Tree_itTree);
  2162.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  2163.         IO_WriteNl(Tree_f);
  2164.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  2165.         IO_WriteNl(Tree_f);
  2166.         IO_WriteS(Tree_f, (STRING)" (yyt) register ", 16L);
  2167.         Tree_WI(Tree_itTree);
  2168.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  2169.         IO_WriteNl(Tree_f);
  2170.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  2171.         IO_WriteNl(Tree_f);
  2172.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  2173.         IO_WriteNl(Tree_f);
  2174.         IO_WriteS(Tree_f, (STRING)" register ", 10L);
  2175.         Tree_WI(Tree_itTree);
  2176.         IO_WriteS(Tree_f, (STRING)" yyr;", 5L);
  2177.         IO_WriteNl(Tree_f);
  2178.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  2179.         IO_WriteNl(Tree_f);
  2180.         {
  2181.           SHORTCARD B_5 = 0, B_6 = (MaxBit - 1) / TreeC1_BSS;
  2182.  
  2183.           if (B_5 <= B_6)
  2184.             for (i = B_5;; i += 1) {
  2185.               IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyIsComp", 22L);
  2186.               Tree_WN((LONGINT)i);
  2187.               IO_WriteS(Tree_f, (STRING)" = 0;", 5L);
  2188.               IO_WriteNl(Tree_f);
  2189.               if (Sets_IsElement(ORD('5'), &Tree_Options)) {
  2190.                 IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyIsDone", 22L);
  2191.                 Tree_WN((LONGINT)i);
  2192.                 IO_WriteS(Tree_f, (STRING)" = 0;", 5L);
  2193.                 IO_WriteNl(Tree_f);
  2194.               }
  2195.               if (i >= B_6) break;
  2196.             }
  2197.         }
  2198.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  2199.         IO_WriteNl(Tree_f);
  2200.         Tree_ForallClasses(W_16->Classes, (Tree_ProcOfT)InitAttributes);
  2201.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  2202.         IO_WriteNl(Tree_f);
  2203.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2204.         IO_WriteNl(Tree_f);
  2205.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  2206.         IO_WriteNl(Tree_f);
  2207.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2208.         IO_WriteNl(Tree_f);
  2209.         IO_WriteNl(Tree_f);
  2210.       }
  2211.       IO_WriteS(Tree_f, (STRING)"void Begin", 10L);
  2212.       Tree_WI(Tree_iModule);
  2213.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  2214.       IO_WriteNl(Tree_f);
  2215.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  2216.       IO_WriteNl(Tree_f);
  2217.       TreeC2_WriteLine(W_16->TreeCodes->U_1.V_12.Codes.BeginLine);
  2218.       Texts_WriteText(Tree_f, W_16->TreeCodes->U_1.V_12.Codes.Begin);
  2219.       Node = W_16->Modules;
  2220.       while (Node->U_1.V_1.Kind == Tree_Module) {
  2221.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.BeginLine);
  2222.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Begin);
  2223.         Node = Node->U_1.V_43.Module.Next;
  2224.       }
  2225.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  2226.       IO_WriteNl(Tree_f);
  2227.       IO_WriteNl(Tree_f);
  2228.       IO_WriteS(Tree_f, (STRING)"void Close", 10L);
  2229.       Tree_WI(Tree_iModule);
  2230.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  2231.       IO_WriteNl(Tree_f);
  2232.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  2233.       IO_WriteNl(Tree_f);
  2234.       TreeC2_WriteLine(W_16->TreeCodes->U_1.V_12.Codes.CloseLine);
  2235.       Texts_WriteText(Tree_f, W_16->TreeCodes->U_1.V_12.Codes.Close);
  2236.       Node = W_16->Modules;
  2237.       while (Node->U_1.V_1.Kind == Tree_Module) {
  2238.         TreeC2_WriteLine(Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.CloseLine);
  2239.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.TreeCodes->U_1.V_12.Codes.Close);
  2240.         Node = Node->U_1.V_43.Module.Next;
  2241.       }
  2242.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  2243.       IO_WriteNl(Tree_f);
  2244.       return;
  2245.     }
  2246.   }
  2247. }
  2248.  
  2249. static void ProcedureBodyn
  2250. # ifdef __STDC__
  2251. (Tree_tTree t)
  2252. # else
  2253. (t)
  2254. Tree_tTree t;
  2255. # endif
  2256. {
  2257.   struct S_12 yyTempo;
  2258.  
  2259.   if (t == Tree_NoTree) {
  2260.     return;
  2261.   }
  2262.   if (t->U_1.V_1.Kind == Tree_Class) {
  2263.     {
  2264.       register Tree_yClass *W_17 = &t->U_1.V_5.Class;
  2265.  
  2266.       if ((Tree_NoCodeClass & W_17->Properties) == 0X0L) {
  2267.         Tree_WI(Tree_itTree);
  2268.         IO_WriteS(Tree_f, (STRING)" n", 2L);
  2269.         Tree_WI(W_17->Name);
  2270.         IO_WriteS(Tree_f, (STRING)" () {", 5L);
  2271.         IO_WriteNl(Tree_f);
  2272.         IO_WriteS(Tree_f, (STRING)" register ", 10L);
  2273.         Tree_WI(Tree_itTree);
  2274.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  2275.         IO_WriteNl(Tree_f);
  2276.         IO_WriteS(Tree_f, (STRING)" yyALLOC (yyt, ", 15L);
  2277.         Tree_WI(Tree_iMain);
  2278.         IO_WriteS(Tree_f, (STRING)"_NodeSize [k", 12L);
  2279.         Tree_WI(W_17->Name);
  2280.         IO_WriteS(Tree_f, (STRING)"])", 2L);
  2281.         IO_WriteNl(Tree_f);
  2282.         IO_WriteS(Tree_f, (STRING)" yyt->Kind = k", 14L);
  2283.         Tree_WI(W_17->Name);
  2284.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2285.         IO_WriteNl(Tree_f);
  2286.         IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyMark = 0;", 24L);
  2287.         IO_WriteNl(Tree_f);
  2288.         if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  2289.           IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyParent = ", 24L);
  2290.           Tree_WI(Tree_iNoTree);
  2291.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2292.           IO_WriteNl(Tree_f);
  2293.         }
  2294.         iClassName = W_17->Name;
  2295.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureBodyn);
  2296.         IO_WriteS(Tree_f, (STRING)" return yyt;", 12L);
  2297.         IO_WriteNl(Tree_f);
  2298.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2299.         IO_WriteNl(Tree_f);
  2300.         IO_WriteNl(Tree_f);
  2301.       }
  2302.       return;
  2303.     }
  2304.   }
  2305.   if (t->U_1.V_1.Kind == Tree_Child) {
  2306.     {
  2307.       register Tree_yChild *W_18 = &t->U_1.V_9.Child;
  2308.  
  2309.       IO_WriteS(Tree_f, (STRING)" begin", 6L);
  2310.       Tree_WI(Tree_itTree);
  2311.       IO_WriteS(Tree_f, (STRING)"(yyt->", 6L);
  2312.       Tree_WI(iClassName);
  2313.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2314.       Tree_WI(W_18->Name);
  2315.       IO_WriteS(Tree_f, (STRING)")", 1L);
  2316.       IO_WriteNl(Tree_f);
  2317.       return;
  2318.     }
  2319.   }
  2320.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2321.     {
  2322.       register Tree_yAttribute *W_19 = &t->U_1.V_10.Attribute;
  2323.  
  2324.       if ((Tree_NoCodeAttr & W_19->Properties) == 0X0L) {
  2325.         IO_WriteS(Tree_f, (STRING)" begin", 6L);
  2326.         Tree_WI(W_19->Type);
  2327.         IO_WriteS(Tree_f, (STRING)"(yyt->", 6L);
  2328.         Tree_WI(iClassName);
  2329.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2330.         Tree_WI(W_19->Name);
  2331.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2332.         IO_WriteNl(Tree_f);
  2333.       }
  2334.       return;
  2335.     }
  2336.   }
  2337. }
  2338.  
  2339. static void ProcedureBodym
  2340. # ifdef __STDC__
  2341. (Tree_tTree t)
  2342. # else
  2343. (t)
  2344. Tree_tTree t;
  2345. # endif
  2346. {
  2347.   struct S_13 yyTempo;
  2348.  
  2349.   if (t == Tree_NoTree) {
  2350.     return;
  2351.   }
  2352.   if (t->U_1.V_1.Kind == Tree_Class) {
  2353.     {
  2354.       register Tree_yClass *W_20 = &t->U_1.V_5.Class;
  2355.  
  2356.       if ((Tree_NoCodeClass & W_20->Properties) == 0X0L) {
  2357.         ProcedureHeadingm(t);
  2358.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  2359.         IO_WriteNl(Tree_f);
  2360.         IO_WriteS(Tree_f, (STRING)" register ", 10L);
  2361.         Tree_WI(Tree_itTree);
  2362.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  2363.         IO_WriteNl(Tree_f);
  2364.         IO_WriteS(Tree_f, (STRING)" yyALLOC (yyt, ", 15L);
  2365.         Tree_WI(Tree_iMain);
  2366.         IO_WriteS(Tree_f, (STRING)"_NodeSize [k", 12L);
  2367.         Tree_WI(W_20->Name);
  2368.         IO_WriteS(Tree_f, (STRING)"])", 2L);
  2369.         IO_WriteNl(Tree_f);
  2370.         IO_WriteS(Tree_f, (STRING)" yyt->Kind = k", 14L);
  2371.         Tree_WI(W_20->Name);
  2372.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2373.         IO_WriteNl(Tree_f);
  2374.         IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyMark = 0;", 24L);
  2375.         IO_WriteNl(Tree_f);
  2376.         if (Sets_IsElement(ORD('L'), &Tree_Options)) {
  2377.           IO_WriteS(Tree_f, (STRING)" yyt->yyHead.yyParent = ", 24L);
  2378.           Tree_WI(Tree_iNoTree);
  2379.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2380.           IO_WriteNl(Tree_f);
  2381.         }
  2382.         iClassName = W_20->Name;
  2383.         Tree_ForallAttributes(t, (Tree_ProcOfT)ProcedureBodym);
  2384.         IO_WriteS(Tree_f, (STRING)" return yyt;", 12L);
  2385.         IO_WriteNl(Tree_f);
  2386.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  2387.         IO_WriteNl(Tree_f);
  2388.         IO_WriteNl(Tree_f);
  2389.       }
  2390.       return;
  2391.     }
  2392.   }
  2393.   if (t->U_1.V_1.Kind == Tree_Child) {
  2394.     {
  2395.       register Tree_yChild *W_21 = &t->U_1.V_9.Child;
  2396.  
  2397.       if (IN(Tree_Input, W_21->Properties)) {
  2398.         IO_WriteS(Tree_f, (STRING)" yyt->", 6L);
  2399.         Tree_WI(iClassName);
  2400.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2401.         Tree_WI(W_21->Name);
  2402.         IO_WriteS(Tree_f, (STRING)" = p", 4L);
  2403.         Tree_WI(W_21->Name);
  2404.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2405.         IO_WriteNl(Tree_f);
  2406.       } else {
  2407.         IO_WriteS(Tree_f, (STRING)" begin", 6L);
  2408.         Tree_WI(Tree_itTree);
  2409.         IO_WriteS(Tree_f, (STRING)"(yyt->", 6L);
  2410.         Tree_WI(iClassName);
  2411.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2412.         Tree_WI(W_21->Name);
  2413.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2414.         IO_WriteNl(Tree_f);
  2415.       }
  2416.       return;
  2417.     }
  2418.   }
  2419.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2420.     {
  2421.       register Tree_yAttribute *W_22 = &t->U_1.V_10.Attribute;
  2422.  
  2423.       if ((Tree_NoCodeAttr & W_22->Properties) == 0X0L) {
  2424.         if (IN(Tree_Input, W_22->Properties)) {
  2425.           IO_WriteS(Tree_f, (STRING)" yyt->", 6L);
  2426.           Tree_WI(iClassName);
  2427.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2428.           Tree_WI(W_22->Name);
  2429.           IO_WriteS(Tree_f, (STRING)" = p", 4L);
  2430.           Tree_WI(W_22->Name);
  2431.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2432.           IO_WriteNl(Tree_f);
  2433.         } else {
  2434.           IO_WriteS(Tree_f, (STRING)" begin", 6L);
  2435.           Tree_WI(W_22->Type);
  2436.           IO_WriteS(Tree_f, (STRING)"(yyt->", 6L);
  2437.           Tree_WI(iClassName);
  2438.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2439.           Tree_WI(W_22->Name);
  2440.           IO_WriteS(Tree_f, (STRING)")", 1L);
  2441.           IO_WriteNl(Tree_f);
  2442.         }
  2443.       }
  2444.       return;
  2445.     }
  2446.   }
  2447. }
  2448.  
  2449. static void ReleaseAttributes1
  2450. # ifdef __STDC__
  2451. (Tree_tTree t)
  2452. # else
  2453. (t)
  2454. Tree_tTree t;
  2455. # endif
  2456. {
  2457.   struct S_14 yyTempo;
  2458.  
  2459.   if (t == Tree_NoTree) {
  2460.     return;
  2461.   }
  2462.   if (t->U_1.V_1.Kind == Tree_Class) {
  2463.     {
  2464.       register Tree_yClass *W_23 = &t->U_1.V_5.Class;
  2465.  
  2466.       if ((Tree_NoCodeClass & W_23->Properties) == 0X0L && IN(Tree_HasChildren, W_23->Properties)) {
  2467.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2468.         Tree_WI(W_23->Name);
  2469.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2470.         IO_WriteNl(Tree_f);
  2471.         iClassName = W_23->Name;
  2472.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReleaseAttributes1);
  2473.         IO_WriteS(Tree_f, (STRING)"break;", 6L);
  2474.         IO_WriteNl(Tree_f);
  2475.       }
  2476.       return;
  2477.     }
  2478.   }
  2479.   if (t->U_1.V_1.Kind == Tree_Child) {
  2480.     {
  2481.       register Tree_yChild *W_24 = &t->U_1.V_9.Child;
  2482.  
  2483.       IO_WriteS(Tree_f, (STRING)"close", 5L);
  2484.       Tree_WI(Tree_itTree);
  2485.       IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  2486.       Tree_WI(iClassName);
  2487.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2488.       Tree_WI(W_24->Name);
  2489.       IO_WriteS(Tree_f, (STRING)")", 1L);
  2490.       IO_WriteNl(Tree_f);
  2491.       return;
  2492.     }
  2493.   }
  2494. }
  2495.  
  2496. static void ReleaseAttributes2
  2497. # ifdef __STDC__
  2498. (Tree_tTree t)
  2499. # else
  2500. (t)
  2501. Tree_tTree t;
  2502. # endif
  2503. {
  2504.   struct S_15 yyTempo;
  2505.  
  2506.   if (t == Tree_NoTree) {
  2507.     return;
  2508.   }
  2509.   if (t->U_1.V_1.Kind == Tree_Class) {
  2510.     {
  2511.       register Tree_yClass *W_25 = &t->U_1.V_5.Class;
  2512.  
  2513.       if ((Tree_NoCodeClass & W_25->Properties) == 0X0L && IN(Tree_HasAttributes, W_25->Properties)) {
  2514.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2515.         Tree_WI(W_25->Name);
  2516.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2517.         IO_WriteNl(Tree_f);
  2518.         iClassName = W_25->Name;
  2519.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReleaseAttributes2);
  2520.         IO_WriteS(Tree_f, (STRING)"break;", 6L);
  2521.         IO_WriteNl(Tree_f);
  2522.       }
  2523.       return;
  2524.     }
  2525.   }
  2526.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2527.     {
  2528.       register Tree_yAttribute *W_26 = &t->U_1.V_10.Attribute;
  2529.  
  2530.       if ((Tree_NoCodeAttr & W_26->Properties) == 0X0L) {
  2531.         IO_WriteS(Tree_f, (STRING)"close", 5L);
  2532.         Tree_WI(W_26->Type);
  2533.         IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  2534.         Tree_WI(iClassName);
  2535.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2536.         Tree_WI(W_26->Name);
  2537.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2538.         IO_WriteNl(Tree_f);
  2539.       }
  2540.       return;
  2541.     }
  2542.   }
  2543. }
  2544.  
  2545. static void TraverseTD
  2546. # ifdef __STDC__
  2547. (Tree_tTree t)
  2548. # else
  2549. (t)
  2550. Tree_tTree t;
  2551. # endif
  2552. {
  2553.   struct S_16 yyTempo;
  2554.  
  2555.   if (t == Tree_NoTree) {
  2556.     return;
  2557.   }
  2558.   if (t->U_1.V_1.Kind == Tree_Class) {
  2559.     {
  2560.       register Tree_yClass *W_27 = &t->U_1.V_5.Class;
  2561.  
  2562.       if ((Tree_NoCodeClass & W_27->Properties) == 0X0L && IN(Tree_HasChildren, W_27->Properties)) {
  2563.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2564.         Tree_WI(W_27->Name);
  2565.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2566.         IO_WriteNl(Tree_f);
  2567.         TreeC2_GetIterator(t);
  2568.         iClassName = W_27->Name;
  2569.         Tree_ForallAttributes(t, (Tree_ProcOfT)TraverseTD);
  2570.         if (TreeC2_Iterator == Tree_NoTree) {
  2571.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  2572.           IO_WriteNl(Tree_f);
  2573.         } else {
  2574.           IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  2575.           Tree_WI(iClassName);
  2576.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2577.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  2578.           IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  2579.           IO_WriteNl(Tree_f);
  2580.         }
  2581.       }
  2582.       return;
  2583.     }
  2584.   }
  2585.   if (t->U_1.V_1.Kind == Tree_Child) {
  2586.     {
  2587.       register Tree_yChild *W_28 = &t->U_1.V_9.Child;
  2588.  
  2589.       if (t != TreeC2_Iterator) {
  2590.         IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2591.         Tree_WI(Tree_iModule);
  2592.         IO_WriteS(Tree_f, (STRING)"TD (yyt->", 9L);
  2593.         Tree_WI(iClassName);
  2594.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2595.         Tree_WI(W_28->Name);
  2596.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2597.         IO_WriteNl(Tree_f);
  2598.       }
  2599.       return;
  2600.     }
  2601.   }
  2602. }
  2603.  
  2604. static void TraverseBU
  2605. # ifdef __STDC__
  2606. (Tree_tTree t)
  2607. # else
  2608. (t)
  2609. Tree_tTree t;
  2610. # endif
  2611. {
  2612.   struct S_17 yyTempo;
  2613.  
  2614.   if (t == Tree_NoTree) {
  2615.     return;
  2616.   }
  2617.   if (t->U_1.V_1.Kind == Tree_Class) {
  2618.     {
  2619.       register Tree_yClass *W_29 = &t->U_1.V_5.Class;
  2620.  
  2621.       if ((Tree_NoCodeClass & W_29->Properties) == 0X0L && IN(Tree_HasChildren, W_29->Properties)) {
  2622.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2623.         Tree_WI(W_29->Name);
  2624.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2625.         IO_WriteNl(Tree_f);
  2626.         TreeC2_GetIterator(t);
  2627.         iClassName = W_29->Name;
  2628.         Tree_ForallAttributes(t, (Tree_ProcOfT)TraverseBU);
  2629.         if (TreeC2_Iterator == Tree_NoTree) {
  2630.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  2631.           IO_WriteNl(Tree_f);
  2632.         } else {
  2633.           IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2634.           Tree_WI(Tree_iModule);
  2635.           IO_WriteS(Tree_f, (STRING)"BU (yyt->", 9L);
  2636.           Tree_WI(iClassName);
  2637.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2638.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  2639.           IO_WriteS(Tree_f, (STRING)"); break;", 9L);
  2640.           IO_WriteNl(Tree_f);
  2641.         }
  2642.       }
  2643.       return;
  2644.     }
  2645.   }
  2646.   if (t->U_1.V_1.Kind == Tree_Child) {
  2647.     {
  2648.       register Tree_yChild *W_30 = &t->U_1.V_9.Child;
  2649.  
  2650.       if (t != TreeC2_Iterator) {
  2651.         IO_WriteS(Tree_f, (STRING)"yyTraverse", 10L);
  2652.         Tree_WI(Tree_iModule);
  2653.         IO_WriteS(Tree_f, (STRING)"BU (yyt->", 9L);
  2654.         Tree_WI(iClassName);
  2655.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2656.         Tree_WI(W_30->Name);
  2657.         IO_WriteS(Tree_f, (STRING)");", 2L);
  2658.         IO_WriteNl(Tree_f);
  2659.       }
  2660.       return;
  2661.     }
  2662.   }
  2663. }
  2664.  
  2665. static void Reverse1
  2666. # ifdef __STDC__
  2667. (Tree_tTree t)
  2668. # else
  2669. (t)
  2670. Tree_tTree t;
  2671. # endif
  2672. {
  2673.   struct S_18 yyTempo;
  2674.  
  2675.   if (t == Tree_NoTree) {
  2676.     return;
  2677.   }
  2678.   if (t->U_1.V_1.Kind == Tree_Class) {
  2679.     {
  2680.       register Tree_yClass *W_31 = &t->U_1.V_5.Class;
  2681.  
  2682.       if ((Tree_NoCodeClass & W_31->Properties) == 0X0L) {
  2683.         iClassName = W_31->Name;
  2684.         Tree_ForallAttributes(t, (Tree_ProcOfT)Reverse1);
  2685.       }
  2686.       return;
  2687.     }
  2688.   }
  2689.   if (t->U_1.V_1.Kind == Tree_Child) {
  2690.     {
  2691.       register Tree_yChild *W_32 = &t->U_1.V_9.Child;
  2692.  
  2693.       if (IN(Tree_Reverse, W_32->Properties)) {
  2694.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2695.         Tree_WI(iClassName);
  2696.         IO_WriteS(Tree_f, (STRING)": yyNext = yyOld->", 18L);
  2697.         Tree_WI(iClassName);
  2698.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2699.         Tree_WI(W_32->Name);
  2700.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2701.         IO_WriteS(Tree_f, (STRING)" yyOld->", 8L);
  2702.         Tree_WI(iClassName);
  2703.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2704.         Tree_WI(W_32->Name);
  2705.         IO_WriteS(Tree_f, (STRING)" = yyNew; break;", 16L);
  2706.         IO_WriteNl(Tree_f);
  2707.       }
  2708.       return;
  2709.     }
  2710.   }
  2711. }
  2712.  
  2713. static void Reverse2
  2714. # ifdef __STDC__
  2715. (Tree_tTree t)
  2716. # else
  2717. (t)
  2718. Tree_tTree t;
  2719. # endif
  2720. {
  2721.   struct S_19 yyTempo;
  2722.  
  2723.   if (t == Tree_NoTree) {
  2724.     return;
  2725.   }
  2726.   if (t->U_1.V_1.Kind == Tree_Class) {
  2727.     {
  2728.       register Tree_yClass *W_33 = &t->U_1.V_5.Class;
  2729.  
  2730.       if ((Tree_NoCodeClass & W_33->Properties) == 0X0L) {
  2731.         iClassName = W_33->Name;
  2732.         Tree_ForallAttributes(t, (Tree_ProcOfT)Reverse2);
  2733.       }
  2734.       return;
  2735.     }
  2736.   }
  2737.   if (t->U_1.V_1.Kind == Tree_Child) {
  2738.     {
  2739.       register Tree_yChild *W_34 = &t->U_1.V_9.Child;
  2740.  
  2741.       if (IN(Tree_Reverse, W_34->Properties)) {
  2742.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2743.         Tree_WI(iClassName);
  2744.         IO_WriteS(Tree_f, (STRING)": yyTail->", 10L);
  2745.         Tree_WI(iClassName);
  2746.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2747.         Tree_WI(W_34->Name);
  2748.         IO_WriteS(Tree_f, (STRING)" = yyOld; break;", 16L);
  2749.         IO_WriteNl(Tree_f);
  2750.       }
  2751.       return;
  2752.     }
  2753.   }
  2754. }
  2755.  
  2756. static void Copy
  2757. # ifdef __STDC__
  2758. (Tree_tTree t)
  2759. # else
  2760. (t)
  2761. Tree_tTree t;
  2762. # endif
  2763. {
  2764.   struct S_20 yyTempo;
  2765.  
  2766.   if (t == Tree_NoTree) {
  2767.     return;
  2768.   }
  2769.   if (t->U_1.V_1.Kind == Tree_Class) {
  2770.     {
  2771.       register Tree_yClass *W_35 = &t->U_1.V_5.Class;
  2772.  
  2773.       if ((Tree_NoCodeClass & W_35->Properties) == 0X0L) {
  2774.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2775.         Tree_WI(W_35->Name);
  2776.         IO_WriteS(Tree_f, (STRING)": (* yyNew)->", 13L);
  2777.         Tree_WI(W_35->Name);
  2778.         IO_WriteS(Tree_f, (STRING)" = yyt->", 8L);
  2779.         Tree_WI(W_35->Name);
  2780.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2781.         IO_WriteNl(Tree_f);
  2782.         TreeC2_GetIterator(t);
  2783.         iClassName = W_35->Name;
  2784.         Tree_ForallAttributes(t, (Tree_ProcOfT)Copy);
  2785.         if (TreeC2_Iterator == Tree_NoTree) {
  2786.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  2787.           IO_WriteNl(Tree_f);
  2788.         } else {
  2789.           IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  2790.           Tree_WI(W_35->Name);
  2791.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2792.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  2793.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2794.           IO_WriteNl(Tree_f);
  2795.           IO_WriteS(Tree_f, (STRING)"yyNew = & (* yyNew)->", 21L);
  2796.           Tree_WI(W_35->Name);
  2797.           IO_WriteS(Tree_f, (STRING)".", 1L);
  2798.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  2799.           IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  2800.           IO_WriteNl(Tree_f);
  2801.         }
  2802.       }
  2803.       return;
  2804.     }
  2805.   }
  2806.   if (t->U_1.V_1.Kind == Tree_Child) {
  2807.     {
  2808.       register Tree_yChild *W_36 = &t->U_1.V_9.Child;
  2809.  
  2810.       if (t != TreeC2_Iterator) {
  2811.         IO_WriteS(Tree_f, (STRING)"copy", 4L);
  2812.         Tree_WI(Tree_itTree);
  2813.         IO_WriteS(Tree_f, (STRING)" ((* yyNew)->", 13L);
  2814.         Tree_WI(iClassName);
  2815.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2816.         Tree_WI(W_36->Name);
  2817.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2818.         IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  2819.         Tree_WI(iClassName);
  2820.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2821.         Tree_WI(W_36->Name);
  2822.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2823.         IO_WriteNl(Tree_f);
  2824.       }
  2825.       return;
  2826.     }
  2827.   }
  2828.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  2829.     {
  2830.       register Tree_yAttribute *W_37 = &t->U_1.V_10.Attribute;
  2831.  
  2832.       if ((Tree_NoCodeAttr & W_37->Properties) == 0X0L) {
  2833.         IO_WriteS(Tree_f, (STRING)"copy", 4L);
  2834.         Tree_WI(W_37->Type);
  2835.         IO_WriteS(Tree_f, (STRING)" ((* yyNew)->", 13L);
  2836.         Tree_WI(iClassName);
  2837.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2838.         Tree_WI(W_37->Name);
  2839.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  2840.         IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  2841.         Tree_WI(iClassName);
  2842.         IO_WriteS(Tree_f, (STRING)".", 1L);
  2843.         Tree_WI(W_37->Name);
  2844.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2845.         IO_WriteNl(Tree_f);
  2846.       }
  2847.       return;
  2848.     }
  2849.   }
  2850. }
  2851.  
  2852. static void CheckAttributes
  2853. # ifdef __STDC__
  2854. (Tree_tTree t)
  2855. # else
  2856. (t)
  2857. Tree_tTree t;
  2858. # endif
  2859. {
  2860.   struct S_21 yyTempo;
  2861.  
  2862.   if (t == Tree_NoTree) {
  2863.     return;
  2864.   }
  2865.   if (t->U_1.V_1.Kind == Tree_Class) {
  2866.     {
  2867.       register Tree_yClass *W_38 = &t->U_1.V_5.Class;
  2868.  
  2869.       if ((Tree_NoCodeClass & W_38->Properties) == 0X0L && IN(Tree_HasChildren, W_38->Properties)) {
  2870.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2871.         Tree_WI(W_38->Name);
  2872.         IO_WriteS(Tree_f, (STRING)":", 1L);
  2873.         IO_WriteNl(Tree_f);
  2874.         iClassName = W_38->Name;
  2875.         Tree_ForallAttributes(t, (Tree_ProcOfT)CheckAttributes);
  2876.         IO_WriteS(Tree_f, (STRING)"break;", 6L);
  2877.         IO_WriteNl(Tree_f);
  2878.       }
  2879.       return;
  2880.     }
  2881.   }
  2882.   if (t->U_1.V_1.Kind == Tree_Child) {
  2883.     {
  2884.       register Tree_yChild *W_39 = &t->U_1.V_9.Child;
  2885.  
  2886.       IO_WriteS(Tree_f, (STRING)"yyResult = yyCheckChild (yyt, yyt->", 35L);
  2887.       Tree_WI(iClassName);
  2888.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2889.       Tree_WI(W_39->Name);
  2890.       IO_WriteS(Tree_f, (STRING)", k", 3L);
  2891.       Tree_WI(W_39->Type);
  2892.       IO_WriteS(Tree_f, (STRING)", \"", 3L);
  2893.       Tree_WI(W_39->Name);
  2894.       IO_WriteS(Tree_f, (STRING)"\") && yyResult;", 15L);
  2895.       IO_WriteNl(Tree_f);
  2896.       return;
  2897.     }
  2898.   }
  2899. }
  2900.  
  2901. static void InitTypeRange
  2902. # ifdef __STDC__
  2903. (Tree_tTree t)
  2904. # else
  2905. (t)
  2906. Tree_tTree t;
  2907. # endif
  2908. {
  2909.   struct S_22 yyTempo;
  2910.  
  2911.   if (t == Tree_NoTree) {
  2912.     return;
  2913.   }
  2914.   if (t->U_1.V_1.Kind == Tree_Class) {
  2915.     {
  2916.       register Tree_yClass *W_40 = &t->U_1.V_5.Class;
  2917.  
  2918.       if ((Tree_NoCodeClass & W_40->Properties) == 0X0L) {
  2919.         iRange = W_40->Name;
  2920.         Tree_ForallClasses(W_40->Extensions, (Tree_ProcOfT)InitTypeRange2);
  2921.         IO_WriteS(Tree_f, (STRING)" k", 2L);
  2922.         Tree_WI(iRange);
  2923.         IO_WriteS(Tree_f, (STRING)",", 1L);
  2924.         IO_WriteNl(Tree_f);
  2925.       }
  2926.       return;
  2927.     }
  2928.   }
  2929. }
  2930.  
  2931. static void InitTypeRange2
  2932. # ifdef __STDC__
  2933. (Tree_tTree t)
  2934. # else
  2935. (t)
  2936. Tree_tTree t;
  2937. # endif
  2938. {
  2939.   struct S_23 yyTempo;
  2940.  
  2941.   if (t == Tree_NoTree) {
  2942.     return;
  2943.   }
  2944.   if (t->U_1.V_1.Kind == Tree_Class) {
  2945.     {
  2946.       register Tree_yClass *W_41 = &t->U_1.V_5.Class;
  2947.  
  2948.       iRange = W_41->Name;
  2949.       return;
  2950.     }
  2951.   }
  2952. }
  2953.  
  2954. static void QueryAttributes
  2955. # ifdef __STDC__
  2956. (Tree_tTree t)
  2957. # else
  2958. (t)
  2959. Tree_tTree t;
  2960. # endif
  2961. {
  2962.   struct S_24 yyTempo;
  2963.  
  2964.   if (t == Tree_NoTree) {
  2965.     return;
  2966.   }
  2967.   if (t->U_1.V_1.Kind == Tree_Class) {
  2968.     {
  2969.       register Tree_yClass *W_42 = &t->U_1.V_5.Class;
  2970.  
  2971.       if ((Tree_NoCodeClass & W_42->Properties) == 0X0L && IN(Tree_HasChildren, W_42->Properties)) {
  2972.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  2973.         Tree_WI(W_42->Name);
  2974.         IO_WriteS(Tree_f, (STRING)": if (false) ;", 14L);
  2975.         IO_WriteNl(Tree_f);
  2976.         iClassName = W_42->Name;
  2977.         Tree_ForallAttributes(t, (Tree_ProcOfT)QueryAttributes);
  2978.         IO_WriteS(Tree_f, (STRING)"break;", 6L);
  2979.         IO_WriteNl(Tree_f);
  2980.       }
  2981.       return;
  2982.     }
  2983.   }
  2984.   if (t->U_1.V_1.Kind == Tree_Child) {
  2985.     {
  2986.       register Tree_yChild *W_43 = &t->U_1.V_9.Child;
  2987.  
  2988.       IO_WriteS(Tree_f, (STRING)"else if (yyyIsEqual (\"", 22L);
  2989.       Tree_WI(W_43->Name);
  2990.       IO_WriteS(Tree_f, (STRING)"\")) Query", 9L);
  2991.       Tree_WI(Tree_iModule);
  2992.       IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  2993.       Tree_WI(iClassName);
  2994.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2995.       Tree_WI(W_43->Name);
  2996.       IO_WriteS(Tree_f, (STRING)");", 2L);
  2997.       IO_WriteNl(Tree_f);
  2998.       return;
  2999.     }
  3000.   }
  3001. }
  3002.  
  3003. static void IsEqualAttributes
  3004. # ifdef __STDC__
  3005. (Tree_tTree t)
  3006. # else
  3007. (t)
  3008. Tree_tTree t;
  3009. # endif
  3010. {
  3011.   struct S_25 yyTempo;
  3012.  
  3013.   if (t == Tree_NoTree) {
  3014.     return;
  3015.   }
  3016.   if (t->U_1.V_1.Kind == Tree_Class) {
  3017.     {
  3018.       register Tree_yClass *W_44 = &t->U_1.V_5.Class;
  3019.  
  3020.       if ((Tree_NoCodeClass & W_44->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_44->Properties) != 0X0L) {
  3021.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  3022.         Tree_WI(W_44->Name);
  3023.         IO_WriteS(Tree_f, (STRING)": return true", 13L);
  3024.         IO_WriteNl(Tree_f);
  3025.         iClassName = W_44->Name;
  3026.         Tree_ForallAttributes(t, (Tree_ProcOfT)IsEqualAttributes);
  3027.         IO_WriteS(Tree_f, (STRING)";", 1L);
  3028.         IO_WriteNl(Tree_f);
  3029.       }
  3030.       return;
  3031.     }
  3032.   }
  3033.   if (t->U_1.V_1.Kind == Tree_Child) {
  3034.     {
  3035.       register Tree_yChild *W_45 = &t->U_1.V_9.Child;
  3036.  
  3037.       IO_WriteS(Tree_f, (STRING)"&& equal", 8L);
  3038.       Tree_WI(Tree_itTree);
  3039.       IO_WriteS(Tree_f, (STRING)" (yyt1->", 8L);
  3040.       Tree_WI(iClassName);
  3041.       IO_WriteS(Tree_f, (STRING)".", 1L);
  3042.       Tree_WI(W_45->Name);
  3043.       IO_WriteS(Tree_f, (STRING)", yyt2->", 8L);
  3044.       Tree_WI(iClassName);
  3045.       IO_WriteS(Tree_f, (STRING)".", 1L);
  3046.       Tree_WI(W_45->Name);
  3047.       IO_WriteS(Tree_f, (STRING)")", 1L);
  3048.       IO_WriteNl(Tree_f);
  3049.       return;
  3050.     }
  3051.   }
  3052.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  3053.     {
  3054.       register Tree_yAttribute *W_46 = &t->U_1.V_10.Attribute;
  3055.  
  3056.       if ((Tree_NoCodeAttr & W_46->Properties) == 0X0L) {
  3057.         IO_WriteS(Tree_f, (STRING)"&& (equal", 9L);
  3058.         Tree_WI(W_46->Type);
  3059.         IO_WriteS(Tree_f, (STRING)" (yyt1->", 8L);
  3060.         Tree_WI(iClassName);
  3061.         IO_WriteS(Tree_f, (STRING)".", 1L);
  3062.         Tree_WI(W_46->Name);
  3063.         IO_WriteS(Tree_f, (STRING)", yyt2->", 8L);
  3064.         Tree_WI(iClassName);
  3065.         IO_WriteS(Tree_f, (STRING)".", 1L);
  3066.         Tree_WI(W_46->Name);
  3067.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  3068.         IO_WriteNl(Tree_f);
  3069.       }
  3070.       return;
  3071.     }
  3072.   }
  3073. }
  3074.  
  3075. static void InitAttributes
  3076. # ifdef __STDC__
  3077. (Tree_tTree t)
  3078. # else
  3079. (t)
  3080. Tree_tTree t;
  3081. # endif
  3082. {
  3083.   struct S_26 yyTempo;
  3084.  
  3085.   if (t == Tree_NoTree) {
  3086.     return;
  3087.   }
  3088.   if (t->U_1.V_1.Kind == Tree_Class) {
  3089.     for (;;) {
  3090.       {
  3091.         register Tree_yClass *W_47 = &t->U_1.V_5.Class;
  3092.  
  3093.         if (!((Tree_NoCodeClass & W_47->Properties) == 0X0L && IN(Tree_HasChildren, W_47->Properties))) {
  3094.           goto EXIT_1;
  3095.         }
  3096.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  3097.         Tree_WI(W_47->Name);
  3098.         IO_WriteS(Tree_f, (STRING)":", 1L);
  3099.         IO_WriteNl(Tree_f);
  3100.         TreeC2_GetIterator(t);
  3101.         iClassName = W_47->Name;
  3102.         gBitCount = W_47->BitCount;
  3103.         Tree_ForallAttributes(t, (Tree_ProcOfT)InitAttributes);
  3104.         if (TreeC2_Iterator == Tree_NoTree || !IN(Tree_Input, TreeC2_Iterator->U_1.V_9.Child.Properties)) {
  3105.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  3106.           IO_WriteNl(Tree_f);
  3107.         } else {
  3108.           IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  3109.           Tree_WI(iClassName);
  3110.           IO_WriteS(Tree_f, (STRING)".", 1L);
  3111.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  3112.           IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  3113.           IO_WriteNl(Tree_f);
  3114.         }
  3115.         return;
  3116.       }
  3117.     } EXIT_1:;
  3118.   }
  3119.   if (t->U_1.V_1.Kind == Tree_Child) {
  3120.     for (;;) {
  3121.       {
  3122.         register Tree_yChild *W_48 = &t->U_1.V_9.Child;
  3123.  
  3124.         if (!IN(Tree_Input, W_48->Properties)) {
  3125.           goto EXIT_2;
  3126.         }
  3127.         IO_WriteS(Tree_f, (STRING)"yyr = yyt->", 11L);
  3128.         Tree_WI(iClassName);
  3129.         IO_WriteS(Tree_f, (STRING)".", 1L);
  3130.         Tree_WI(W_48->Name);
  3131.         IO_WriteS(Tree_f, (STRING)"; yyr->yyHead.yyOffset = ", 25L);
  3132.         Tree_WN((LONGINT)(gBitCount + W_48->BitOffset));
  3133.         IO_WriteS(Tree_f, (STRING)"; yyr->yyHead.yyParent = yyt;", 29L);
  3134.         IO_WriteNl(Tree_f);
  3135.         if (!(t != TreeC2_Iterator)) {
  3136.           goto EXIT_2;
  3137.         }
  3138.         IO_WriteS(Tree_f, (STRING)"Init", 4L);
  3139.         Tree_WI(Tree_iModule);
  3140.         IO_WriteS(Tree_f, (STRING)" (yyr);", 7L);
  3141.         IO_WriteNl(Tree_f);
  3142.         return;
  3143.       }
  3144.     } EXIT_2:;
  3145.   }
  3146. }
  3147.  
  3148. static void InitNodeSize
  3149. # ifdef __STDC__
  3150. (Tree_tTree t)
  3151. # else
  3152. (t)
  3153. Tree_tTree t;
  3154. # endif
  3155. {
  3156.   struct S_27 yyTempo;
  3157.  
  3158.   if (t == Tree_NoTree) {
  3159.     return;
  3160.   }
  3161.   if (t->U_1.V_1.Kind == Tree_Class) {
  3162.     {
  3163.       register Tree_yClass *W_49 = &t->U_1.V_5.Class;
  3164.  
  3165.       if ((Tree_NoCodeClass & W_49->Properties) == 0X0L) {
  3166.         IO_WriteS(Tree_f, (STRING)" sizeof (y", 10L);
  3167.         Tree_WI(W_49->Name);
  3168.         IO_WriteS(Tree_f, (STRING)"),", 2L);
  3169.         IO_WriteNl(Tree_f);
  3170.       }
  3171.       return;
  3172.     }
  3173.   }
  3174. }
  3175.  
  3176. static void InitNodeName
  3177. # ifdef __STDC__
  3178. (Tree_tTree t)
  3179. # else
  3180. (t)
  3181. Tree_tTree t;
  3182. # endif
  3183. {
  3184.   struct S_28 yyTempo;
  3185.  
  3186.   if (t == Tree_NoTree) {
  3187.     return;
  3188.   }
  3189.   if (t->U_1.V_1.Kind == Tree_Class) {
  3190.     {
  3191.       register Tree_yClass *W_50 = &t->U_1.V_5.Class;
  3192.  
  3193.       if ((Tree_NoCodeClass & W_50->Properties) == 0X0L) {
  3194.         IO_WriteS(Tree_f, (STRING)" \"", 2L);
  3195.         Tree_WI(W_50->Name);
  3196.         IO_WriteS(Tree_f, (STRING)"\",", 2L);
  3197.         IO_WriteNl(Tree_f);
  3198.       }
  3199.       return;
  3200.     }
  3201.   }
  3202. }
  3203.  
  3204. static void CompMaxBit
  3205. # ifdef __STDC__
  3206. (Tree_tTree t)
  3207. # else
  3208. (t)
  3209. Tree_tTree t;
  3210. # endif
  3211. {
  3212.   struct S_29 yyTempo;
  3213.  
  3214.   if (t == Tree_NoTree) {
  3215.     return;
  3216.   }
  3217.   if (t->U_1.V_1.Kind == Tree_Class) {
  3218.     {
  3219.       register Tree_yClass *W_51 = &t->U_1.V_5.Class;
  3220.  
  3221.       i = 1;
  3222.       Tree_ForallAttributes(t, (Tree_ProcOfT)CompMaxBit);
  3223.       MaxBit = General_Max((LONGINT)i, (LONGINT)MaxBit);
  3224.       return;
  3225.     }
  3226.   }
  3227.   if (t->U_1.V_1.Kind == Tree_Child) {
  3228.     for (;;) {
  3229.       {
  3230.         register Tree_yChild *W_52 = &t->U_1.V_9.Child;
  3231.  
  3232.         if (!(((SET_ELEM(Tree_Input) | SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_52->Properties) == 0X0L)) {
  3233.           goto EXIT_3;
  3234.         }
  3235.         INC(i);
  3236.         return;
  3237.       }
  3238.     } EXIT_3:;
  3239.   }
  3240.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  3241.     for (;;) {
  3242.       {
  3243.         register Tree_yAttribute *W_53 = &t->U_1.V_10.Attribute;
  3244.  
  3245.         if (!(((SET_ELEM(Tree_Input) | SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_53->Properties) == 0X0L)) {
  3246.           goto EXIT_4;
  3247.         }
  3248.         INC(i);
  3249.         return;
  3250.       }
  3251.     } EXIT_4:;
  3252.   }
  3253. }
  3254.  
  3255. void TreeC1_BeginTreeC1
  3256. # ifdef __STDC__
  3257. ()
  3258. # else
  3259. ()
  3260. # endif
  3261. {
  3262.   ConstCount = 0;
  3263. }
  3264.  
  3265. void TreeC1_CloseTreeC1
  3266. # ifdef __STDC__
  3267. ()
  3268. # else
  3269. ()
  3270. # endif
  3271. {
  3272. }
  3273.  
  3274. static void yyExit
  3275. # ifdef __STDC__
  3276. ()
  3277. # else
  3278. ()
  3279. # endif
  3280. {
  3281.   IO_CloseIO();
  3282.   Exit(1L);
  3283. }
  3284.  
  3285. void BEGIN_TreeC1()
  3286. {
  3287.   static BOOLEAN has_been_called = FALSE;
  3288.  
  3289.   if (!has_been_called) {
  3290.     has_been_called = TRUE;
  3291.  
  3292.     BEGIN_IO();
  3293.     BEGIN_Tree();
  3294.     BEGIN_System();
  3295.     BEGIN_IO();
  3296.     BEGIN_Tree();
  3297.     BEGIN_General();
  3298.     BEGIN_IO();
  3299.     BEGIN_Idents();
  3300.     BEGIN_Texts();
  3301.     BEGIN_Sets();
  3302.     BEGIN_TreeC2();
  3303.     BEGIN_Tree();
  3304.     BEGIN_Strings();
  3305.  
  3306.     TreeC1_yyf = IO_StdOutput;
  3307.     TreeC1_Exit = yyExit;
  3308.     TreeC1_BeginTreeC1();
  3309.   }
  3310. }
  3311.